C#

BillWoodruff wrote:

I assumed that because the 'Node class itself is constrained in the way shown in my code example ... implements IEquatable, and the 'TestClass is also constrained and implements IEquatable, that it was not necessary for me to also constrain the 'Gather method.

BillWoodruff wrote:

I am off to the gym to try and sauna and swim my way out of the 96F

BillWoodruff wrote:

Big thank you !

// You can't do this: (#1)
public static class NodeExtensions<T>
{
    public static Dictionary<int, List<int>> Gather(this Node<T> node, GatherMode gathermode, Func<Node<T>, Node<T>, bool> customfunc = null)
    {
        ...
    }
}

// You can't do this either: (#2)
public static class NodeExtensions
{
    public static Dictionary<int, List<int>> Gather(this Node<T> node, GatherMode gathermode, Func<Node<T>, Node<T>, bool> customfunc = null)
    {
        ...
    }
}

// But you can do this:
public static class NodeExtensions
{
    public static Dictionary<int, List<int>> Gather<T>(this Node<T> node, GatherMode gathermode, Func<Node<T>, Node<T>, bool> customfunc = null) where T : IEquatable<T>
    {
        ...
    }
}

SqlConnection con = new SqlConnection@"DataSource=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|NewDB1.mdf;Integrated Security=True;User Instance=True");

Working with local databases[^]

This connection string syntax is supported by the SqlClient and OleDb managed providers.

By default, the |DataDirectory| variable will be expanded as follow:

• For applications placed in a directory on the user machine, this will be the app's (.exe) folder;
• For apps running under ClickOnce, this will be a special data folder created by ClickOnce;
• For Web apps, this will be the App_Data folder;

Brisingr Aerowing wrote:

Countered down vote.

Jayamanickam wrote:

but it will not run a setup file different sysytem

[Test]
public void MultipleReaders()
{

        using (concurrencyTester = new ConcurrencyTester())
        {
            this.Given(c => c.new_reader_writer_lock())
                .And(c => c.i_start_read_operation(1))
                .And(c => c.i_wait_till_read_operation_is_pending(1))
                .And(c => c.i_start_write_operation(1))
                .And(c => c.i_start_read_operation(2))
                .And(c => c.i_wait_till_read_operation_is_pending(2))
                .And(c => c.i_start_write_operation(2))
                .When(c => c.release_read_operations(new[] { 1, 2 }))
                .And(c => c.release_write_operations(new[] { 1, 2 }))
                .And(c => c.wait_for_test_end())
                .Then(c => c.write_operations_should_not_intersect_with_read_operations())
                .And(c => c.write_operations_should_not_intersect_with_other_write_operations())
                .BDDfy();

            concurrencyTester.Marks.DumpTimeline();
        }
}

void i_start_write_operation(int number)
{
    concurrencyTester.Start(
                     c =>
                     {
                         readerWriterLock.EnterWriteLock();
                         using (concurrencyTester.Marks["Write"].BeginSection())
                         {
                             concurrencyTester.Events[WriteOperationPending, number].Wait();
                         }
                         readerWriterLock.ExitWriteLock();
                     }, "Write Operation #{0}", number);
}

void write_operations_should_not_intersect_with_read_operations()
{
    foreach (var intersect in this.concurrencyTester.Marks["Write"].Sections.SelectMany(readSection => readSection.Relations.Intersect))
    {
        intersect.Mark.Name.ShouldNotBe("Read");
    }
}

Thomas Maierhofer (Tom) wrote:

this.Given(c => c.new_reader_writer_lock())
.And(c => c.i_start_read_operation(1))
.And(c => c.i_wait_till_read_operation_is_pending(1))
.And(c => c.i_start_write_operation(1))
.And(c => c.i_start_read_operation(2))
.And(c => c.i_wait_till_read_operation_is_pending(2))
.And(c => c.i_start_write_operation(2))
.When(c => c.release_read_operations(new[] { 1, 2 }))
.And(c => c.release_write_operations(new[] { 1, 2 }))
.And(c => c.wait_for_test_end())
.Then(c => c.write_operations_should_not_intersect_with_read_operations())
.And(c => c.write_operations_should_not_intersect_with_other_write_operations())
.BDDfy();

Thomas Maierhofer (Tom) wrote:

So it should become very easy to write concurrency tests with this framework

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

void i_start_write_operation(int number)
{
    concurrencyTester.Start(
                     c =>
                     {
                         readerWriterLock.EnterWriteLock();
                         using (concurrencyTester.Marks["Write"].BeginSection())
                         {
                             concurrencyTester.Events[WriteOperationPending, number].Wait();
                         }
                         readerWriterLock.ExitWriteLock();
                     }, "Write Operation #{0}", number);
}

void release_write_operations(int[] numbers)
{

    foreach (var number in numbers)
    {
        concurrencyTester.Events[WriteOperationPending, number].Set();
    }

}

.When(c => c.release_read_operations(new[] { 1, 2 }))
.And(c => c.release_write_operations(new[] { 1, 2 }))

Thomas Maierhofer (Tom) wrote:

Behavior Driven Tests have all the same structure:

Thomas Maierhofer (Tom) wrote:

Our old approach of concurrency testing does not fit in very well:

Thomas Maierhofer (Tom) wrote:

You can't split this up semantically in Given/When/Then

Thomas Maierhofer (Tom) wrote:

Without the concurrency tester this is much harder to test.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]