public void Parse_string_scalar_and_sequence_adjacent(string[] arguments, FakeOptionsWithScalarValueAndSequenceStringAdjacent expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithScalarValueAndSequenceStringAdjacent> >(() => new FakeOptionsWithScalarValueAndSequenceStringAdjacent()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
expected.ShouldBeEquivalentTo(result.Value);
// Teardown
}
public void Parse_nullable_long(string[] arguments, long?expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithNullables> >(() => new FakeOptionsWithNullables()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
expected.ShouldBeEquivalentTo(result.Value.NullableLong);
// Teardown
}
public void Parse_string_scalar_with_required_constraint_as_value(string[] arguments, FakeOptionsWithRequiredValue expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithRequiredValue> >(() => new FakeOptionsWithRequiredValue()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
expected.ShouldBeEquivalentTo(result.Value);
// Teardown
}
public void Parse_double_value(string[] arguments, double expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithDouble> >(() => new FakeOptionsWithDouble()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.Equal(expected, result.Value.DoubleValue);
// Teardown
}
public void Parse_utf8_string_correctly(string[] arguments, string expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptions> >(() => new FakeOptions()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
expected.ShouldBeEquivalentTo(result.Value.StringValue);
// Teardown
}
public void Omitting_names_assumes_identifier_as_long_name(string[] arguments, string expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptions> >(() => new FakeOptions()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expected.Equals(result.Value.StringValue));
// Teardown
}
public void Parse_string_sequence_with_separator(string[] arguments, string[] expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithSequenceAndSeparator> >(() => new FakeOptionsWithSequenceAndSeparator()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
expected.ShouldBeEquivalentTo(result.Value.StringSequence);
// Teardown
}
public void Parse_enum_value(string[] arguments, Colors expected)
{
// Fixture setup in attribute
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithEnum> >(() => new FakeOptionsWithEnum()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
expected.ShouldBeEquivalentTo(result.Value.Colors);
// Teardown
}
public void Parse_to_immutable_instance(string[] arguments, FakeImmutableOptions expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Nothing <Func <FakeImmutableOptions> >(),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
expected.ShouldBeEquivalentTo(result.Value);
// Teardown
}
public void Parse_int_sequence_with_range(string[] arguments, int[] expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptions> >(() => new FakeOptions()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expected.SequenceEqual(result.Value.IntSequence));
// Teardown
}
private static Instance ParseClass(string fullFileName, IEnumerable <Member> members)
{
//TODO: Gross
var parts = fullFileName.Split('\\').ToList();
var fileName = parts.Last();
var className = fileName.Split('.')[0];
parts.RemoveRange(parts.Count - 1, 1);
var packageLocation = string.Join("\\", parts);
parts.RemoveAt(0);
var packageName = string.Join(".", parts);
var codeBag = new CodeBag(packageName, CodeBagType.Package, packageLocation);
return(InstanceBuilder.Build(codeBag, className, new Location(Path.Combine(packageLocation, fileName)), members));
}
public void Parse_string_sequence_with_only_max_constraint(string[] arguments, string[] expected)
{
// Fixture setup with attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithSequenceAndOnlyMaxConstraint> >(() => new FakeOptionsWithSequenceAndOnlyMaxConstraint()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expected.SequenceEqual(result.Value.StringSequence));
// Teardown
}
public void ShouldNotApplyWhenPhysicalPathDiffers()
{
var mbr = new Member("store", 1, 1, 1);
var cls = InstanceBuilder.Build(new CodeBag("dev", CodeBagType.Namespace, @"C:\dev"), "name", @"C:\dev\name.cs", 1, 1, 3, 1, new[] { mbr });
var toApply = InstanceBuilder.Build(new CodeBag("dev", CodeBagType.Namespace, @"C:\dev"), "namexxx", @"C:\dev\namexxx.cs", 2, 2, 2, 2, new[] { mbr });
cls.Apply(toApply);
Validate.Begin().IsNotNull(cls, "class")
.IsEqual(cls.Members.Count, 1, "mbr count")
.IsEqual(cls.NumberOfMethods, 1, "# Methods")
.IsEqual(cls.LinesOfCode, 1, "loc")
.IsEqual(cls.CyclomaticComplexity, 1, "cyclo")
.IsEqual(cls.DepthOfInheritance, 3, "DIT")
.IsEqual(cls.ClassCoupling, 1, "class coupling")
.Check();
}
public void Breaking_equal_min_max_constraint_in_string_sequence_as_value_gererates_SequenceOutOfRangeError()
{
// Fixture setup
var expectedResult = new[] { new SequenceOutOfRangeError(NameInfo.EmptyName) };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithSequenceMinMaxEqual> >(() => new FakeOptionsWithSequenceMinMaxEqual()),
new[] { "one", "two", "this-is-too-much" },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(((NotParsed <FakeOptionsWithSequenceMinMaxEqual>)result).Errors));
// Teardown
}
public void Breaking_required_constraint_in_string_scalar_as_value_generates_MissingRequiredOptionError()
{
// Fixture setup
var expectedResult = new[] { new MissingRequiredOptionError(NameInfo.EmptyName) };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithRequiredValue> >(() => new FakeOptionsWithRequiredValue()),
new string[] { },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(((NotParsed <FakeOptionsWithRequiredValue>)result).Errors));
// Teardown
}
public void Parse_unknown_short_option_in_option_group_gererates_UnknownOptionError()
{
// Fixture setup
var expectedResult = new[] { new UnknownOptionError("z") };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptions> >(() => new FakeOptions()),
new[] { "-zx" },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(((NotParsed <FakeOptions>)result).Errors));
// Teardown
}
public void Wrong_range_in_sequence_gererates_SequenceOutOfRangeError()
{
// Fixture setup
var expectedResult = new[] { new SequenceOutOfRangeError(new NameInfo("i", "")) };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptions> >(() => new FakeOptions()),
new [] { "-i", "10" },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(((NotParsed <FakeOptions>)result).Errors));
// Teardown
}
public void Omitting_required_option_gererates_MissingRequiredOptionError()
{
// Fixture setup
var expectedResult = new[] { new MissingRequiredOptionError(new NameInfo("", "str")) };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithRequired> >(() => new FakeOptionsWithRequired()),
new string[] { },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(((NotParsed <FakeOptionsWithRequired>)result).Errors));
// Teardown
}
public void Parse_string_scalar_and_sequence_adjacent(string[] arguments, Options_With_Scalar_Value_And_Adjacent_SequenceString expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <Options_With_Scalar_Value_And_Adjacent_SequenceString> >(() => new Options_With_Scalar_Value_And_Adjacent_SequenceString()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture,
Enumerable.Empty <ErrorType>());
// Verify outcome
expected.ShouldBeEquivalentTo(((Parsed <Options_With_Scalar_Value_And_Adjacent_SequenceString>)result).Value);
// Teardown
}
public void Parse_int_sequence(string[] arguments, int[] expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <Options_With_Sequence> >(() => new Options_With_Sequence()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture,
Enumerable.Empty <ErrorType>());
// Verify outcome
((Parsed <Options_With_Sequence>)result).Value.IntSequence.ShouldBeEquivalentTo(expected);
// Teardown
}
public void Parse_utf8_string_correctly(string[] arguments, string expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <Simple_Options> >(() => new Simple_Options()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture,
Enumerable.Empty <ErrorType>());
// Verify outcome
expected.ShouldBeEquivalentTo(((Parsed <Simple_Options>)result).Value.StringValue);
// Teardown
}
public void Parse_to_immutable_instance(string[] arguments, Immutable_Simple_Options expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Nothing <Func <Immutable_Simple_Options> >(),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture,
Enumerable.Empty <ErrorType>());
// Verify outcome
expected.ShouldBeEquivalentTo(((Parsed <Immutable_Simple_Options>)result).Value);
// Teardown
}
public void Parse_long_sequence_with_separator(string[] arguments, long[] expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <Options_With_Sequence_Having_Separator_Set> >(() => new Options_With_Sequence_Having_Separator_Set()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture,
Enumerable.Empty <ErrorType>());
// Verify outcome
expected.ShouldBeEquivalentTo(((Parsed <Options_With_Sequence_Having_Separator_Set>)result).Value.LongSequence);
// Teardown
}
public void Parse_unknown_long_option_gererates_UnknownOptionError()
{
// Fixture setup
var expectedResult = new[] { new UnknownOptionError("xyz") };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptions> >(() => new FakeOptions()),
new[] { "--stringvalue", "abc", "--xyz" },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(result.Errors));
// Teardown
}
public void Parse_nullable_long(string[] arguments, long?expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <Options_With_Nullables> >(() => new Options_With_Nullables()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture,
Enumerable.Empty <ErrorType>());
// Verify outcome
expected.ShouldBeEquivalentTo(((Parsed <Options_With_Nullables>)result).Value.NullableLong);
// Teardown
}
public void Breaking_min_constraint_in_string_sequence_gererates_MissingValueOptionError()
{
// Fixture setup
var expectedResult = new[] { new MissingValueOptionError(new NameInfo("s", "string-seq")) };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithSequenceAndOnlyMinConstraint> >(() => new FakeOptionsWithSequenceAndOnlyMinConstraint()),
new[] { "-s" },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(((NotParsed <FakeOptionsWithSequenceAndOnlyMinConstraint>)result).Errors));
// Teardown
}
public void Parse_string_scalar_with_required_constraint_as_value(string[] arguments, Options_With_Required_Set_To_True_For_Values expected)
{
// Fixture setup in attributes
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <Options_With_Required_Set_To_True_For_Values> >(() => new Options_With_Required_Set_To_True_For_Values()),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture,
Enumerable.Empty <ErrorType>());
// Verify outcome
expected.ShouldBeEquivalentTo(((Parsed <Options_With_Required_Set_To_True_For_Values>)result).Value);
// Teardown
}
public void Breaking_max_constraint_in_string_sequence_gererates_SequenceOutOfRangeError()
{
// Fixture setup
var expectedResult = new[] { new SequenceOutOfRangeError(new NameInfo("s", "string-seq")) };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithSequenceAndOnlyMaxConstraint> >(() => new FakeOptionsWithSequenceAndOnlyMaxConstraint()),
new[] { "--string-seq=one", "two", "three", "this-is-too-much" },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(((NotParsed <FakeOptionsWithSequenceAndOnlyMaxConstraint>)result).Errors));
// Teardown
}
public void Remove_BufferConnectedToOutputPort_RemoveBuffer()
{
var hostModule = CreateHostModule("test_module");
var builder = new InstanceBuilder(DummyNetlist, hostModule.Name);
_instanceRepository.Add(builder.New("x_buf", "inst1").Add("i", "out").Add("o", "w4").Build());
_instanceRepository.Add(builder.New("an2", "inst2").Add("a", "w1").Add("b", "w2").Add("z", "out").Build());
_target.Remove(DummyNetlist, "x_buf", "i", "o");
var result = _instanceRepository.GetByModuleName(DummyNetlist, "x_buf").ToList();
Assert.That(result, Is.Empty);
result = _instanceRepository.GetByModuleName(DummyNetlist, "an2").ToList();
Assert.That(result[0].Net, Has.Exactly(1).Matches <PortWirePair>(pwp => pwp.Port == "z" && pwp.Wire == "w4"));
}
public void Parse_enum_value_with_wrong_item_name_case_generates_BadFormatConversionError()
{
// Fixture setup
var expectedResult = new[] { new BadFormatConversionError(new NameInfo("", "colors")) };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <FakeOptionsWithEnum> >(() => new FakeOptionsWithEnum()),
new[] { "--colors", "RED" },
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
Assert.True(expectedResult.SequenceEqual(((NotParsed <FakeOptionsWithEnum>)result).Errors));
// Teardown
}
