add working test suite for automated testing

Author: kalidke

test/Project.toml

@@ -0,0 +1,7 @@
+[deps]
+Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+MicroscopePSFs = "de9ac726-48a4-48ab-84b0-1c03c7c18929"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+SMLMData = "5488f106-40b8-4660-84c5-84a168990d1b"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

test/runtests.jl

@@ -1,28 +1,35 @@
 using SMLMSim
 using Test
+using SMLMData
+using Distributions
+using LinearAlgebra
+using MicroscopePSFs
+
+# Include test files
+include("test_patterns.jl")
+include("test_molecules.jl")
+include("test_kinetics.jl")
+include("test_diffusion.jl")
+include("test_imaging_and_analysis.jl")
 
 @testset "SMLMSim.jl" begin
-    # Write your tests here.
+    @testset "Patterns" begin
+        test_patterns()
+    end
 
-    @testset "Interaction Diffusion" begin
-        using MicroscopePSFs
+    @testset "Molecules" begin
+        test_molecules()
+    end
 
-        box_size = 1
-        dt = 0.005
-        density = 2
-        state_history, args = SMLMSim.InteractionDiffusion.smoluchowski(;
-            dt=dt, box_size=box_size, t_max=5.0, density=density, d_dimer=0.05)
-        @test length(state_history.frames) == 1000
-        
-        pixelsize = 0.1
-        pixels = Int64(round(box_size / pixelsize))
-        psf = MicroscopePSFs.Airy2D(1.3, 0.6, pixelsize)
-        camera = SMLMSim.IdealCamera(xpixels=pixels, ypixels=pixels, pixelsize=pixelsize)
-        dimer_history = SMLMSim.InteractionDiffusion.get_dimers(state_history)
-        dimer_stack = SMLMSim.gen_image_stack(psf, dimer_history, camera;
-            photons=1000.0, bg=5.0, poissonnoise=true, frame_integration=10)
-        @test size(dimer_stack) == (pixels, pixels, 100)
+    @testset "Kinetic Modeling" begin
+        test_kinetics()
     end
 
+    @testset "Diffusion" begin
+        test_diffusion()
+    end
 
-end
+    @testset "Imaging & Analysis" begin
+        test_imaging_and_analysis()
+    end
+end

test/test_diffusion.jl

@@ -0,0 +1,98 @@
+using SMLMSim.InteractionDiffusion
+using Random
+# Import the initialize_system function explicitly
+using SMLMSim.InteractionDiffusion: initialize_system
+
+function test_diffusion()
+    @testset "SmoluchowskiParams" begin
+        # Test default constructor
+        params = SmoluchowskiParams()
+        @test params.density == 1.0
+        @test params.box_size == 10.0
+        @test params.dt == 0.01
+        @test params.boundary == "periodic"
+        
+        # Test custom constructor with a few key parameters
+        params = SmoluchowskiParams(
+            density = 2.0,
+            box_size = 20.0,
+            ndims = 3,
+            boundary = "reflecting"
+        )
+        
+        @test params.density == 2.0
+        @test params.box_size == 20.0
+        @test params.ndims == 3
+        @test params.boundary == "reflecting"
+        
+        # Test one invalid parameter case
+        @test_throws ArgumentError SmoluchowskiParams(density = -1.0)
+    end
+    
+    @testset "Diffusion Simulation" begin
+        # Create small system for quick tests
+        params = SmoluchowskiParams(
+            density = 1.0,
+            box_size = 1.0,
+            dt = 0.01,
+            t_max = 0.05  # Just 5 frames
+        )
+        
+        # Test system initialization
+        system = initialize_system(params)
+        expected_molecules = round(Int, params.density * params.box_size^params.ndims)
+        @test length(system.molecules) == expected_molecules
+        
+        # Test basic simulation
+        systems = simulate(params)
+        @test length(systems) == round(Int, params.t_max / params.dt)
+        
+        # Test dimer formation with parameters favoring dimers
+        params_dimer = SmoluchowskiParams(
+            density = 10.0,     # High density
+            box_size = 1.0,     # Small box
+            r_react = 0.1,      # Large reaction radius
+            k_off = 0.01,       # Slow dissociation
+            dt = 0.01,
+            t_max = 0.1         # Short but likely sufficient for dimers
+        )
+        
+        systems_dimer = simulate(params_dimer)
+        
+        # Check if dimers formed
+        final_system = systems_dimer[end]
+        n_dimers = count(m -> m.state == 2, final_system.molecules)
+        
+        # Print rather than test - dimers might not form in all cases
+        @info "Number of dimers formed: $n_dimers out of $(length(final_system.molecules)) molecules"
+    end
+    
+    @testset "Dimer Analysis" begin
+        # Create a system with some dimers
+        params = SmoluchowskiParams(box_size = 1.0, density = 5.0)
+        system = initialize_system(params)
+        
+        # Make some molecules into dimers
+        n_molecules = length(system.molecules)
+        n_dimers = min(2, div(n_molecules, 2))
+        for i in 1:n_dimers
+            mol1 = system.molecules[2*i-1]
+            mol2 = system.molecules[2*i]
+            mol1.state = 2
+            mol2.state = 2
+            mol1.link = mol2.id
+            mol2.link = mol1.id
+        end
+        
+        # Test get_dimers
+        dimer_system = get_dimers(system)
+        @test length(dimer_system.molecules) == 2 * n_dimers
+        @test all(m -> m.state == 2, dimer_system.molecules)
+        
+        # Test analyze_dimer_fraction
+        fractions = analyze_dimer_fraction([system])
+        @test length(fractions) == 1
+        expected_fraction = 2 * n_dimers / n_molecules
+        @test fractions[1] ≈ expected_fraction
+    end
+end

test/test_imaging_and_analysis.jl

@@ -0,0 +1,163 @@
+using SMLMSim.InteractionDiffusion
+using MicroscopePSFs
+using Random
+
+function test_imaging_and_analysis()
+    @testset "Image Generation" begin
+        # Create a simple system with one molecule
+        camera = IdealCamera(1:50, 1:50, 0.1)  # 5μm x 5μm field with 100nm pixels
+        emitter = Emitter2D{Float64}(2.5, 2.5, 1000.0)  # Center of field
+        molecule = DiffusingMolecule(emitter, 1, 1, nothing, false)
+        
+        system = DiffusingMoleculeSystem(
+            [molecule], camera, 5.0, 1, 1, Dict{String,Any}()
+        )
+        
+        # Create PSF and generate image
+        psf = Gaussian2D(0.15)
+        img = gen_image(psf, system, 1, photons=1000.0, bg=5.0, poisson_noise=false)
+        
+        # Test basic image properties
+        @test size(img) == (length(camera.pixel_edges_y)-1, length(camera.pixel_edges_x)-1)
+        @test all(img .>= 5.0)  # At least background everywhere
+        
+        # Test image sequence generation
+        # Create a minimal simulation
+        params = SmoluchowskiParams(
+            density = 1.0,
+            box_size = 2.0,
+            dt = 0.01,
+            t_max = 0.03  # Just 3 frames
+        )
+        systems = simulate(params)
+        
+        # Generate image sequence
+        imgs = gen_image_sequence(psf, systems, 
+                                 photons=1000.0, bg=5.0, 
+                                 frame_integration=1, poisson_noise=false)
+        
+        # Test basic sequence properties
+        @test size(imgs, 3) == length(systems)
+        
+        # Test frame integration
+        imgs_integrated = gen_image_sequence(psf, systems, 
+                                            photons=1000.0, bg=5.0, 
+                                            frame_integration=3, poisson_noise=false)
+        
+        @test size(imgs_integrated, 3) == 1  # Should have just one frame with integration=3
+    end
+    
+    @testset "Dimer Imaging" begin
+        # Create a system with dimers
+        params = SmoluchowskiParams(
+            density = 5.0,
+            box_size = 1.0,
+            dt = 0.01,
+            t_max = 0.01  # Just one frame
+        )
+        system = initialize_system(params)
+        
+        # Make some molecules into dimers
+        n_molecules = length(system.molecules)
+        n_dimers = min(2, div(n_molecules, 2))
+        for i in 1:n_dimers
+            mol1 = system.molecules[2*i-1]
+            mol2 = system.molecules[2*i]
+            mol1.state = 2
+            mol2.state = 2
+            mol1.link = mol2.id
+            mol2.link = mol1.id
+        end
+        
+        # Create a sequence with just this one system
+        systems = [system]
+        
+        # Create PSF and generate dimer images
+        psf = Gaussian2D(0.15)
+        dimer_images = gen_dimer_images(systems, psf, 
+                                       photons=1000.0, bg=5.0,
+                                       frame_integration=1, poisson_noise=false)
+        
+        # Test basic image properties
+        @test size(dimer_images, 3) == 1
+    end
+    
+    @testset "Full Simulation Pipeline" begin
+        # Test the complete workflow with minimal simulation
+        # This is a crucial test as it ensures all components work together
+        
+        # Create simulation parameters
+        params = SmoluchowskiParams(
+            density = 1.0,
+            box_size = 1.0,
+            dt = 0.01,
+            t_max = 0.02  # Just 2 frames
+        )
+        
+        # Create PSF
+        psf = Gaussian2D(0.15)
+        
+        # Run simulation and imaging
+        images, systems = simulate_and_image(params, psf,
+            photons=1000.0, bg=5.0,
+            frame_integration=1, poisson_noise=false)
+        
+        # Test basic outputs
+        @test isa(images, Array{Float64, 3})
+        @test length(systems) == 2
+        @test size(images, 3) == 2
+    end
+    
+    @testset "Core Interface" begin
+        # Test the main simulate interfaces
+        camera = IdealCamera(1:20, 1:20, 0.1)
+        
+        # Basic interface
+        smld_true, smld_model, smld_noisy = SMLMSim.simulate(
+            ρ=1.0, 
+            camera=camera,
+            nframes=5  # Minimal
+        )
+        
+        # Test basic outputs
+        @test smld_true isa BasicSMLD
+        @test smld_model isa BasicSMLD
+        @test smld_noisy isa BasicSMLD
+        
+        # With explicit pattern
+        pattern = Nmer2D(n=4, d=0.1)
+        smld_true, smld_model, smld_noisy = SMLMSim.simulate(
+            pattern,
+            ρ=1.0,
+            camera=camera,
+            nframes=5
+        )
+        
+        @test smld_true isa BasicSMLD
+    end
+    
+    # Skip visualization tests in normal test runs as they're slow and mostly check for errors
+    if get(ENV, "RUN_VISUALIZATION_TESTS", "false") == "true"
+        @testset "Visualization" begin
+            # Create a small simulation
+            params = SmoluchowskiParams(
+                density = 2.0,
+                box_size = 1.0,
+                dt = 0.01,
+                t_max = 0.03  # Just 3 frames
+            )
+            systems = simulate(params)
+            
+            # Test with a temporary file (no assertion, just checking for errors)
+            temp_file = "test_vis_$(rand(1:1000)).mp4"
+            
+            try
+                visualize_sequence(systems, filename=temp_file, framerate=10)
+            finally
+                if isfile(temp_file)
+                    rm(temp_file)
+                end
+            end
+        end
+    end
+end