[Fork] Task 68 | Step 2 Code and Unit Tests Execution With PE | C# Online Compiler

[Fork] Task 68 | Step 2 Code and Unit Tests Execution With PE by Jomo Lumina

using System;
using System.Threading;
using NUnit.Framework;

public class Program
{
	/// <summary>
	/// Entry point for the program
	/// </summary>
	public static void Main(string[] args)
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int h1 = allocator.Allocate(200);
		int h2 = allocator.Allocate(300);
		allocator.Free(h1);
		int h3 = allocator.Allocate(150); // Should reuse freed space if possible

		allocator.Defragment(); // Should compact memory
		Console.WriteLine(allocator.IsAllocated(h1)); // False
		Console.WriteLine(allocator.IsAllocated(h2)); // True
		Console.WriteLine(allocator.IsAllocated(h3)); // True

		MemoryAllocatorTests tests = new MemoryAllocatorTests();
		RunTest(() => tests.Allocate_ValidSize_ReturnsValidHandle(), "Allocate_ValidSize_ReturnsValidHandle");
		RunTest(() => tests.Allocate_InsufficientMemory_ReturnsNegativeOne(), "Allocate_InsufficientMemory_ReturnsNegativeOne");
		RunTest(() => tests.Allocate_ZeroSize_ThrowsArgumentException(), "Allocate_ZeroSize_ThrowsArgumentException");
		RunTest(() => tests.Free_ValidHandle_FreesMemory(), "Free_ValidHandle_FreesMemory");
		RunTest(() => tests.Free_InvalidHandle_DoesNotThrowException(), "Free_InvalidHandle_DoesNotThrowException");
		RunTest(() => tests.Free_DoubleFree_DoesNotThrowExceptionAndPreventDoubleFree(), "Free_DoubleFree_DoesNotThrowExceptionAndPreventDoubleFree");
		RunTest(() => tests.Defragment_BasicDefragmentation_CompactsMemory(), "Defragment_BasicDefragmentation_CompactsMemory");
		RunTest(() => tests.IsAllocated_ValidHandle_ReturnsTrueIfAllocated(), "IsAllocated_ValidHandle_ReturnsTrueIfAllocated");
		RunTest(() => tests.IsAllocated_ValidHandle_ReturnsFalseIfFreed(), "IsAllocated_ValidHandle_ReturnsFalseIfFreed");
		RunTest(() => tests.IsAllocated_InvalidHandle_ReturnsFalse(), "IsAllocated_InvalidHandle_ReturnsFalse");
		RunTest(() => tests.MemoryAllocator_ZeroSize_ThrowsArgumentException(), "MemoryAllocator_ZeroSize_ThrowsArgumentException");
		RunTest(() => tests.Allocate_ReuseFreedMemory_AllocatesInPreviousFreeBlock(), "Allocate_ReuseFreedMemory_AllocatesInPreviousFreeBlock");
		RunTest(() => tests.ThreadSafetyTest(), "ThreadSafetyTest");
		Console.WriteLine("all tests executed"); // True
	}

	static void RunTest(Action testMethod, string testName)
	{
		try
		{
			testMethod.Invoke();
			Console.WriteLine($"✅ {testName} passed");
		}
		catch (Exception ex)
		{
			Console.WriteLine($"❌ {testName} failed: {ex.Message}");
		}
	}
}

public class MemoryAllocator
{
	private byte[] memory;
	private int memorySize;
	private FreeBlock freeListHead;
	private object lockObject = new object();

	private class FreeBlock
	{
		public int start;
		public int size;
		public FreeBlock next;

		public FreeBlock(int start, int size)
		{
			this.start = start;
			this.size = size;
			this.next = null;
		}
	}

	public MemoryAllocator(int size)
	{
		if (size <= 0)
		{
			throw new ArgumentException("Size must be positive.");
		}

		memorySize = size;
		memory = new byte[size];
		freeListHead = new FreeBlock(0, size);
	}

	public int Allocate(int size)
	{
		if (size <= 0)
		{
			throw new ArgumentException("Size must be positive.");
		}

		lock (lockObject)
		{
			FreeBlock current = freeListHead;
			FreeBlock previous = null;

			while (current != null)
			{
				if (current.size >= size)
				{
					// Found a suitable free block
					int handle = current.start;

					if (current.size == size)
					{
						// Exact match, remove the block from the free list
						if (previous == null)
						{
							freeListHead = current.next;
						}
						else
						{
							previous.next = current.next;
						}
					}
					else
					{
						// Split the block
						current.start += size;
						current.size -= size;
					}

					return handle;
				}

				previous = current;
				current = current.next;
			}

			// No suitable block found
			return -1;
		}
	}

	public void Free(int handle)
	{
		if (handle < 0 || handle >= memorySize)
		{
			return; // Invalid handle, do nothing
		}

		lock (lockObject)
		{
			// Check if the handle is actually allocated
			if (!IsAllocated(handle))
			{
				return; // Prevent double-free
			}

			// Mark the memory as free by adding it to the free list
			FreeBlock newBlock = new FreeBlock(handle, FindAllocatedBlockSize(handle));

			// Insert the new block into the free list, sorted by address
			FreeBlock current = freeListHead;
			FreeBlock previous = null;

			while (current != null && current.start < handle)
			{
				previous = current;
				current = current.next;
			}

			if (previous == null)
			{
				newBlock.next = freeListHead;
				freeListHead = newBlock;
			}
			else
			{
				newBlock.next = current;
				previous.next = newBlock;
			}

			// Coalesce adjacent free blocks
			CoalesceFreeBlocks();
		}
	}

	private int FindAllocatedBlockSize(int handle)
	{
		// Linearly search the memory to determine the size of the allocated block
		int size = 0;
		FreeBlock current = freeListHead;

		while (current != null)
		{
			if (current.start == handle)
			{
				return -1; // Already free
			}
			current = current.next;
		}

		//Calculate the size of the block
		for (int i = handle; i < memorySize; i++)
		{
			bool isFree = false;
			FreeBlock currentBlock = freeListHead;
			while (currentBlock != null)
			{
				if (currentBlock.start == i)
				{
					isFree = true;
					break;
				}
				currentBlock = currentBlock.next;
			}
			if (isFree)
			{
				break;
			}
			size++;
		}

		return size;
	}

	private void CoalesceFreeBlocks()
	{
		FreeBlock current = freeListHead;

		while (current != null && current.next != null)
		{
			if (current.start + current.size == current.next.start)
			{
				// Merge the blocks
				current.size += current.next.size;
				current.next = current.next.next;
			}
			else
			{
				current = current.next;
			}
		}
	}

	public void Defragment()
	{
		lock (lockObject)
		{
			// Create a temporary array to hold the allocated memory
			byte[] tempMemory = new byte[memorySize];
			int currentOffset = 0;

			// Iterate through the memory and copy allocated blocks to the temp array
			int originalOffset = 0;
			while (originalOffset < memorySize)
			{
				bool isFree = false;
				FreeBlock currentBlock = freeListHead;
				while (currentBlock != null)
				{
					if (currentBlock.start == originalOffset)
					{
						isFree = true;
						break;
					}
					currentBlock = currentBlock.next;
				}

				if (!isFree)
				{
					int blockSize = FindAllocatedBlockSize(originalOffset);
					if (blockSize > 0)
					{
						Array.Copy(memory, originalOffset, tempMemory, currentOffset, blockSize);
						currentOffset += blockSize;
						originalOffset += blockSize;
					}
					else
					{
						originalOffset++;
					}
				}
				else
				{
					originalOffset++;
				}
			}

			// Copy the defragmented memory back to the original memory array
			Array.Copy(tempMemory, memory, memorySize);

			// Update the free list
			freeListHead = new FreeBlock(currentOffset, memorySize - currentOffset);
			CoalesceFreeBlocks();
		}
	}

	public bool IsAllocated(int handle)
	{
		if (handle < 0 || handle >= memorySize)
		{
			return false;
		}

		FreeBlock current = freeListHead;
		while (current != null)
		{
			if (current.start == handle)
			{
				return false; // Handle points to a free block
			}
			current = current.next;
			if (current != null && handle >= current.start && handle < current.start + current.size)
			{
				return false;
			}

		}

		// Check if the handle falls within any free block's range
		current = freeListHead;
		while (current != null)
		{
			if (handle >= current.start && handle < current.start + current.size)
			{
				return false; // Handle is within a free block
			}
			current = current.next;
		}

		return FindAllocatedBlockSize(handle) > 0; // Otherwise, assume it's allocated (within valid memory range but not a free block)
	}
}

[TestFixture]
public class MemoryAllocatorTests
{
	[Test]
	public void Allocate_ValidSize_ReturnsValidHandle()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int handle = allocator.Allocate(200);
		Assert.That(handle, Is.GreaterThanOrEqualTo(0));
	}

	[Test]
	public void Allocate_InsufficientMemory_ReturnsNegativeOne()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int handle1 = allocator.Allocate(1024);
		int handle2 = allocator.Allocate(1);
		Assert.That(handle2, Is.EqualTo(-1));
	}

	[Test]
	public void Allocate_ZeroSize_ThrowsArgumentException()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		Assert.Throws<ArgumentException>(() => allocator.Allocate(0));
	}

	[Test]
	public void Free_ValidHandle_FreesMemory()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int handle = allocator.Allocate(200);
		allocator.Free(handle);
		Assert.That(allocator.IsAllocated(handle), Is.False);
	}

	[Test]
	public void Free_InvalidHandle_DoesNotThrowException()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		Assert.DoesNotThrow(() => allocator.Free(-1));
		Assert.DoesNotThrow(() => allocator.Free(2048));
	}

	[Test]
	public void Free_DoubleFree_DoesNotThrowExceptionAndPreventDoubleFree()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int handle = allocator.Allocate(200);
		allocator.Free(handle);
		Assert.DoesNotThrow(() => allocator.Free(handle));
		Assert.That(allocator.IsAllocated(handle), Is.False);
	}

	[Test]
	public void Defragment_BasicDefragmentation_CompactsMemory()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int h1 = allocator.Allocate(200);
		int h2 = allocator.Allocate(300);
		allocator.Free(h1);
		int h3 = allocator.Allocate(150);
		allocator.Defragment();

		Assert.That(allocator.IsAllocated(h1), Is.False);
		Assert.That(allocator.IsAllocated(h2), Is.True);
		Assert.That(allocator.IsAllocated(h3), Is.True);
	}

	[Test]
	public void IsAllocated_ValidHandle_ReturnsTrueIfAllocated()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int handle = allocator.Allocate(200);
		Assert.That(allocator.IsAllocated(handle), Is.True);
	}

	[Test]
	public void IsAllocated_ValidHandle_ReturnsFalseIfFreed()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int handle = allocator.Allocate(200);
		allocator.Free(handle);
		Assert.That(allocator.IsAllocated(handle), Is.False);
	}

	[Test]
	public void IsAllocated_InvalidHandle_ReturnsFalse()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		Assert.That(allocator.IsAllocated(-1), Is.False);
		Assert.That(allocator.IsAllocated(2048), Is.False);
	}

	[Test]
	public void MemoryAllocator_ZeroSize_ThrowsArgumentException()
	{
		Assert.Throws<ArgumentException>(() => new MemoryAllocator(0));
	}

	[Test]
	public void Allocate_ReuseFreedMemory_AllocatesInPreviousFreeBlock()
	{
		MemoryAllocator allocator = new MemoryAllocator(1024);
		int h1 = allocator.Allocate(200);
		allocator.Free(h1);
		int h2 = allocator.Allocate(100); // Should use the freed block from h1

		Assert.That(h2, Is.EqualTo(h1));
		Assert.That(allocator.IsAllocated(h2), Is.True);
	}

	[Test]
	public void ThreadSafetyTest()
	{
		const int numThreads = 10;
		const int numAllocations = 100;
		MemoryAllocator allocator = new MemoryAllocator(1024 * 1024); // 1MB
		Thread[] threads = new Thread[numThreads];

		for (int i = 0; i < numThreads; i++)
		{
			threads[i] = new Thread(() =>
			{
				for (int j = 0; j < numAllocations; j++)
				{
					int size = new Random().Next(100, 500);
					int handle = allocator.Allocate(size);

					if (handle >= 0)
					{
						Thread.Sleep(new Random().Next(1, 10)); // Simulate some work
						allocator.Free(handle);
					}
					else
					{
						Console.WriteLine("Allocation failed");
					}
				}
			});
		}

		foreach (var thread in threads)
		{
			thread.Start();
		}

		foreach (var thread in threads)
		{
			thread.Join();
		}

		// After all threads finish, check for memory corruption (very basic check)
		// A more robust test would involve writing known data to allocated blocks
		// and verifying it after concurrent access.

		Console.WriteLine("Thread safety test completed.");
	}
}

​x
 
using System;
using System.Threading;
using NUnit.Framework;
​
public class Program
{
    /// <summary>
    /// Entry point for the program
    /// </summary>
    public static void Main(string[] args)
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int h1 = allocator.Allocate(200);
        int h2 = allocator.Allocate(300);
        allocator.Free(h1);
        int h3 = allocator.Allocate(150); // Should reuse freed space if possible
​
        allocator.Defragment(); // Should compact memory
        Console.WriteLine(allocator.IsAllocated(h1)); // False
        Console.WriteLine(allocator.IsAllocated(h2)); // True
        Console.WriteLine(allocator.IsAllocated(h3)); // True
​
        MemoryAllocatorTests tests = new MemoryAllocatorTests();
        RunTest(() => tests.Allocate_ValidSize_ReturnsValidHandle(), "Allocate_ValidSize_ReturnsValidHandle");
        RunTest(() => tests.Allocate_InsufficientMemory_ReturnsNegativeOne(), "Allocate_InsufficientMemory_ReturnsNegativeOne");
        RunTest(() => tests.Allocate_ZeroSize_ThrowsArgumentException(), "Allocate_ZeroSize_ThrowsArgumentException");
        RunTest(() => tests.Free_ValidHandle_FreesMemory(), "Free_ValidHandle_FreesMemory");
        RunTest(() => tests.Free_InvalidHandle_DoesNotThrowException(), "Free_InvalidHandle_DoesNotThrowException");
        RunTest(() => tests.Free_DoubleFree_DoesNotThrowExceptionAndPreventDoubleFree(), "Free_DoubleFree_DoesNotThrowExceptionAndPreventDoubleFree");
        RunTest(() => tests.Defragment_BasicDefragmentation_CompactsMemory(), "Defragment_BasicDefragmentation_CompactsMemory");
        RunTest(() => tests.IsAllocated_ValidHandle_ReturnsTrueIfAllocated(), "IsAllocated_ValidHandle_ReturnsTrueIfAllocated");
        RunTest(() => tests.IsAllocated_ValidHandle_ReturnsFalseIfFreed(), "IsAllocated_ValidHandle_ReturnsFalseIfFreed");
        RunTest(() => tests.IsAllocated_InvalidHandle_ReturnsFalse(), "IsAllocated_InvalidHandle_ReturnsFalse");
        RunTest(() => tests.MemoryAllocator_ZeroSize_ThrowsArgumentException(), "MemoryAllocator_ZeroSize_ThrowsArgumentException");
        RunTest(() => tests.Allocate_ReuseFreedMemory_AllocatesInPreviousFreeBlock(), "Allocate_ReuseFreedMemory_AllocatesInPreviousFreeBlock");
        RunTest(() => tests.ThreadSafetyTest(), "ThreadSafetyTest");
        Console.WriteLine("all tests executed"); // True
    }
​
    static void RunTest(Action testMethod, string testName)
    {
        try
        {
            testMethod.Invoke();
            Console.WriteLine($"✅ {testName} passed");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ {testName} failed: {ex.Message}");
        }
    }
}
​
public class MemoryAllocator
{
    private byte[] memory;
    private int memorySize;
    private FreeBlock freeListHead;
    private object lockObject = new object();
​
    private class FreeBlock
    {
        public int start;
        public int size;
        public FreeBlock next;
​
        public FreeBlock(int start, int size)
        {
            this.start = start;
            this.size = size;
            this.next = null;
        }
    }
​
    public MemoryAllocator(int size)
    {
        if (size <= 0)
        {
            throw new ArgumentException("Size must be positive.");
        }
​
        memorySize = size;
        memory = new byte[size];
        freeListHead = new FreeBlock(0, size);
    }
​
    public int Allocate(int size)
    {
        if (size <= 0)
        {
            throw new ArgumentException("Size must be positive.");
        }
​
        lock (lockObject)
        {
            FreeBlock current = freeListHead;
            FreeBlock previous = null;
​
            while (current != null)
            {
                if (current.size >= size)
                {
                    // Found a suitable free block
                    int handle = current.start;
​
                    if (current.size == size)
                    {
                        // Exact match, remove the block from the free list
                        if (previous == null)
                        {
                            freeListHead = current.next;
                        }
                        else
                        {
                            previous.next = current.next;
                        }
                    }
                    else
                    {
                        // Split the block
                        current.start += size;
                        current.size -= size;
                    }
​
                    return handle;
                }
​
                previous = current;
                current = current.next;
            }
​
            // No suitable block found
            return -1;
        }
    }
​
    public void Free(int handle)
    {
        if (handle < 0 || handle >= memorySize)
        {
            return; // Invalid handle, do nothing
        }
​
        lock (lockObject)
        {
            // Check if the handle is actually allocated
            if (!IsAllocated(handle))
            {
                return; // Prevent double-free
            }
​
            // Mark the memory as free by adding it to the free list
            FreeBlock newBlock = new FreeBlock(handle, FindAllocatedBlockSize(handle));
​
            // Insert the new block into the free list, sorted by address
            FreeBlock current = freeListHead;
            FreeBlock previous = null;
​
            while (current != null && current.start < handle)
            {
                previous = current;
                current = current.next;
            }
​
            if (previous == null)
            {
                newBlock.next = freeListHead;
                freeListHead = newBlock;
            }
            else
            {
                newBlock.next = current;
                previous.next = newBlock;
            }
​
            // Coalesce adjacent free blocks
            CoalesceFreeBlocks();
        }
    }
​
    private int FindAllocatedBlockSize(int handle)
    {
        // Linearly search the memory to determine the size of the allocated block
        int size = 0;
        FreeBlock current = freeListHead;
​
        while (current != null)
        {
            if (current.start == handle)
            {
                return -1; // Already free
            }
            current = current.next;
        }
​
        //Calculate the size of the block
        for (int i = handle; i < memorySize; i++)
        {
            bool isFree = false;
            FreeBlock currentBlock = freeListHead;
            while (currentBlock != null)
            {
                if (currentBlock.start == i)
                {
                    isFree = true;
                    break;
                }
                currentBlock = currentBlock.next;
            }
            if (isFree)
            {
                break;
            }
            size++;
        }
​
        return size;
    }
​
    private void CoalesceFreeBlocks()
    {
        FreeBlock current = freeListHead;
​
        while (current != null && current.next != null)
        {
            if (current.start + current.size == current.next.start)
            {
                // Merge the blocks
                current.size += current.next.size;
                current.next = current.next.next;
            }
            else
            {
                current = current.next;
            }
        }
    }
​
    public void Defragment()
    {
        lock (lockObject)
        {
            // Create a temporary array to hold the allocated memory
            byte[] tempMemory = new byte[memorySize];
            int currentOffset = 0;
​
            // Iterate through the memory and copy allocated blocks to the temp array
            int originalOffset = 0;
            while (originalOffset < memorySize)
            {
                bool isFree = false;
                FreeBlock currentBlock = freeListHead;
                while (currentBlock != null)
                {
                    if (currentBlock.start == originalOffset)
                    {
                        isFree = true;
                        break;
                    }
                    currentBlock = currentBlock.next;
                }
​
                if (!isFree)
                {
                    int blockSize = FindAllocatedBlockSize(originalOffset);
                    if (blockSize > 0)
                    {
                        Array.Copy(memory, originalOffset, tempMemory, currentOffset, blockSize);
                        currentOffset += blockSize;
                        originalOffset += blockSize;
                    }
                    else
                    {
                        originalOffset++;
                    }
                }
                else
                {
                    originalOffset++;
                }
            }
​
            // Copy the defragmented memory back to the original memory array
            Array.Copy(tempMemory, memory, memorySize);
​
            // Update the free list
            freeListHead = new FreeBlock(currentOffset, memorySize - currentOffset);
            CoalesceFreeBlocks();
        }
    }
​
    public bool IsAllocated(int handle)
    {
        if (handle < 0 || handle >= memorySize)
        {
            return false;
        }
​
        FreeBlock current = freeListHead;
        while (current != null)
        {
            if (current.start == handle)
            {
                return false; // Handle points to a free block
            }
            current = current.next;
            if (current != null && handle >= current.start && handle < current.start + current.size)
            {
                return false;
            }
​
        }
​
        // Check if the handle falls within any free block's range
        current = freeListHead;
        while (current != null)
        {
            if (handle >= current.start && handle < current.start + current.size)
            {
                return false; // Handle is within a free block
            }
            current = current.next;
        }
​
        return FindAllocatedBlockSize(handle) > 0; // Otherwise, assume it's allocated (within valid memory range but not a free block)
    }
}
​
[TestFixture]
public class MemoryAllocatorTests
{
    [Test]
    public void Allocate_ValidSize_ReturnsValidHandle()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int handle = allocator.Allocate(200);
        Assert.That(handle, Is.GreaterThanOrEqualTo(0));
    }
​
    [Test]
    public void Allocate_InsufficientMemory_ReturnsNegativeOne()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int handle1 = allocator.Allocate(1024);
        int handle2 = allocator.Allocate(1);
        Assert.That(handle2, Is.EqualTo(-1));
    }
​
    [Test]
    public void Allocate_ZeroSize_ThrowsArgumentException()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        Assert.Throws<ArgumentException>(() => allocator.Allocate(0));
    }
​
    [Test]
    public void Free_ValidHandle_FreesMemory()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int handle = allocator.Allocate(200);
        allocator.Free(handle);
        Assert.That(allocator.IsAllocated(handle), Is.False);
    }
​
    [Test]
    public void Free_InvalidHandle_DoesNotThrowException()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        Assert.DoesNotThrow(() => allocator.Free(-1));
        Assert.DoesNotThrow(() => allocator.Free(2048));
    }
​
    [Test]
    public void Free_DoubleFree_DoesNotThrowExceptionAndPreventDoubleFree()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int handle = allocator.Allocate(200);
        allocator.Free(handle);
        Assert.DoesNotThrow(() => allocator.Free(handle));
        Assert.That(allocator.IsAllocated(handle), Is.False);
    }
​
    [Test]
    public void Defragment_BasicDefragmentation_CompactsMemory()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int h1 = allocator.Allocate(200);
        int h2 = allocator.Allocate(300);
        allocator.Free(h1);
        int h3 = allocator.Allocate(150);
        allocator.Defragment();
​
        Assert.That(allocator.IsAllocated(h1), Is.False);
        Assert.That(allocator.IsAllocated(h2), Is.True);
        Assert.That(allocator.IsAllocated(h3), Is.True);
    }
​
    [Test]
    public void IsAllocated_ValidHandle_ReturnsTrueIfAllocated()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int handle = allocator.Allocate(200);
        Assert.That(allocator.IsAllocated(handle), Is.True);
    }
​
    [Test]
    public void IsAllocated_ValidHandle_ReturnsFalseIfFreed()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int handle = allocator.Allocate(200);
        allocator.Free(handle);
        Assert.That(allocator.IsAllocated(handle), Is.False);
    }
​
    [Test]
    public void IsAllocated_InvalidHandle_ReturnsFalse()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        Assert.That(allocator.IsAllocated(-1), Is.False);
        Assert.That(allocator.IsAllocated(2048), Is.False);
    }
​
    [Test]
    public void MemoryAllocator_ZeroSize_ThrowsArgumentException()
    {
        Assert.Throws<ArgumentException>(() => new MemoryAllocator(0));
    }
​
    [Test]
    public void Allocate_ReuseFreedMemory_AllocatesInPreviousFreeBlock()
    {
        MemoryAllocator allocator = new MemoryAllocator(1024);
        int h1 = allocator.Allocate(200);
        allocator.Free(h1);
        int h2 = allocator.Allocate(100); // Should use the freed block from h1
​
        Assert.That(h2, Is.EqualTo(h1));
        Assert.That(allocator.IsAllocated(h2), Is.True);
    }
​
    [Test]
    public void ThreadSafetyTest()
    {
        const int numThreads = 10;
        const int numAllocations = 100;
        MemoryAllocator allocator = new MemoryAllocator(1024 * 1024); // 1MB
        Thread[] threads = new Thread[numThreads];
​
        for (int i = 0; i < numThreads; i++)
        {
            threads[i] = new Thread(() =>
            {
                for (int j = 0; j < numAllocations; j++)
                {
                    int size = new Random().Next(100, 500);
                    int handle = allocator.Allocate(size);
​
                    if (handle >= 0)
                    {
                        Thread.Sleep(new Random().Next(1, 10)); // Simulate some work
                        allocator.Free(handle);
                    }
                    else
                    {
                        Console.WriteLine("Allocation failed");
                    }
                }
            });
        }
​
        foreach (var thread in threads)
        {
            thread.Start();
        }
​
        foreach (var thread in threads)
        {
            thread.Join();
        }
​
        // After all threads finish, check for memory corruption (very basic check)
        // A more robust test would involve writing known data to allocated blocks
        // and verifying it after concurrent access.
​
        Console.WriteLine("Thread safety test completed.");
    }
}

Compilation error (line 11, col 16): Expected class, delegate, enum, interface, or struct
Compilation error (line 14, col 1): Type or namespace definition, or end-of-file expected

Last Run:	3:05:27 pm
Compile:	0s
Execute:	0.032s
Memory:	0b
CPU:	0s

View IL Code