void Run(EqualityUnit<LineRange> equalityUnit)
{
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
equalityUnit);
}
public void EqualsNamespace()
{
var ns1 = CreateEqualsInterface <INamespace>("namespace");
var ns2 = CreateEqualsInterface <INamespace>("namespace");
var ns3 = CreateEqualsInterface <INamespace>("other namespace");
var value = UsedNamespaceOrType.CreateNamespace(ns1.Object);
var unit = EqualityUnit
.Create(value)
.WithEqualValues(
value,
UsedNamespaceOrType.CreateNamespace(ns1.Object),
UsedNamespaceOrType.CreateNamespace(ns2.Object)
)
.WithNotEqualValues(
UsedNamespaceOrType.CreateExternAlias("alias"),
UsedNamespaceOrType.CreateNamespace(
ns1.Object,
CreateEqualsInterface <IAssemblyReference>("a").Object
),
UsedNamespaceOrType.CreateNamespace(ns3.Object)
);
RunAll(unit);
}
private void Run(EqualityUnit<SearchData> equalityUnit)
{
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
equalityUnit);
}
public void EqualsTargetTypeSameValue()
{
var type1 = CreateEqualsInterface <ITypeReference>("type name");
var type2 = CreateEqualsInterface <ITypeReference>("type name");
var type3 = CreateEqualsInterface <ITypeReference>("other type name");
Assert.True(type1.Object.Equals(type2.Object));
Assert.False(type1.Object.Equals(type3.Object));
Assert.True(object.Equals(type1.Object, type2.Object));
var value = UsedNamespaceOrType.CreateType(type1.Object, "alias");
var unit = EqualityUnit
.Create(value)
.WithEqualValues(
value,
UsedNamespaceOrType.CreateType(type1.Object, "alias"),
UsedNamespaceOrType.CreateType(type2.Object, "alias"))
.WithNotEqualValues(
UsedNamespaceOrType.CreateType(type1.Object, "different alias"),
UsedNamespaceOrType.CreateType(type2.Object, "different alias"),
UsedNamespaceOrType.CreateType(type3.Object, "alias"),
UsedNamespaceOrType.CreateNamespace(new Mock <INamespace>().Object));
RunAll(unit);
}
public void EqualsNamespaceAndAssembly()
{
var assembly1 = CreateEqualsInterface <IAssemblyReference>("assembly");
var assembly2 = CreateEqualsInterface <IAssemblyReference>("assembly");
var assembly3 = CreateEqualsInterface <IAssemblyReference>("other assembly");
var ns1 = CreateEqualsInterface <INamespace>("namespace");
var ns2 = CreateEqualsInterface <INamespace>("namespace");
var ns3 = CreateEqualsInterface <INamespace>("other namespace");
var value = UsedNamespaceOrType.CreateNamespace(ns1.Object, assembly1.Object);
var unit = EqualityUnit
.Create(value)
.WithEqualValues(
value,
UsedNamespaceOrType.CreateNamespace(ns1.Object, assembly1.Object),
UsedNamespaceOrType.CreateNamespace(ns1.Object, assembly2.Object),
UsedNamespaceOrType.CreateNamespace(ns2.Object, assembly1.Object)
)
.WithNotEqualValues(
UsedNamespaceOrType.CreateExternAlias("alias"),
UsedNamespaceOrType.CreateNamespace(
ns1.Object,
new Mock <IAssemblyReference>(MockBehavior.Strict).Object
),
UsedNamespaceOrType.CreateNamespace(ns3.Object)
);
RunAll(unit);
}
public void Equality1()
{
EqualityUtil.RunAll(
(left, right) => left == right,
(left, right) => left != right,
EqualityUnit.Create(new LinePosition(1, 2)).WithEqualValues(new LinePosition(1, 2)),
EqualityUnit.Create(new LinePosition()).WithEqualValues(new LinePosition()),
EqualityUnit.Create(new LinePosition(1, 2)).WithNotEqualValues(new LinePosition(1, 3)),
EqualityUnit.Create(new LinePosition(1, 2)).WithNotEqualValues(new LinePosition(2, 2)));
}
public void Equality()
{
EqualityUtil.RunAll(
(left, right) => left == right,
(left, right) => left != right,
EqualityUnit.Create(new TextChangeRange()).WithEqualValues(new TextChangeRange()),
EqualityUnit.Create(new TextChangeRange(new TextSpan(42, 2), 13)).WithEqualValues(new TextChangeRange(new TextSpan(42, 2), 13)),
EqualityUnit.Create(new TextChangeRange(new TextSpan(42, 2), 13)).WithNotEqualValues(new TextChangeRange(new TextSpan(42, 2), 5)),
EqualityUnit.Create(new TextChangeRange(new TextSpan(42, 2), 13)).WithNotEqualValues(new TextChangeRange(new TextSpan(42, 4), 13)));
}
public void EqualsExternAlias()
{
var value = UsedNamespaceOrType.CreateExternAlias("alias1");
var unit = EqualityUnit
.Create(value)
.WithEqualValues(value, UsedNamespaceOrType.CreateExternAlias("alias1"))
.WithNotEqualValues(UsedNamespaceOrType.CreateExternAlias("alias2"));
RunAll(unit);
}
public void Equality_AlternatesAreEqual()
{
foreach (var pair in KeyInputUtil.AlternateKeyInputPairList)
{
var unit = EqualityUnit.Create(pair.Item1).WithEqualValues(pair.Item2).WithNotEqualValues(KeyInputUtil.VimKeyToKeyInput(VimKey.Colon));
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
values: unit);
}
}
public void Equality_ControlLetterIsCaseInsensitive()
{
var unit = EqualityUnit.Create(KeyInputUtil.CharWithControlToKeyInput('a'))
.WithEqualValues(KeyInputUtil.CharWithControlToKeyInput('A'))
.WithNotEqualValues(KeyInputUtil.CharToKeyInput('a'));
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
values: unit);
}
public void Equality_Operator()
{
Create("cat", "dog");
EqualityUtil.RunAll(
(left, right) => left == right,
(left, right) => left != right,
false,
false,
EqualityUnit.Create(new CharacterSpan(_textBuffer.GetPoint(0), 1, 2))
.WithEqualValues(new CharacterSpan(_textBuffer.GetPoint(0), 1, 2))
.WithNotEqualValues(new CharacterSpan(_textBuffer.GetPoint(1), 1, 2)));
}
public void LocalizableResourceStringEquality()
{
var resourceManager = GetTestResourceManagerInstance();
var unit = EqualityUnit
.Create(
new LocalizableResourceString(
@"ResourceWithArguments",
resourceManager,
typeof(CustomResourceManager),
"arg"
)
)
.WithEqualValues(
new LocalizableResourceString(
@"ResourceWithArguments",
resourceManager,
typeof(CustomResourceManager),
"arg"
)
)
.WithNotEqualValues(
new LocalizableResourceString(
@"ResourceWithArguments",
resourceManager,
typeof(CustomResourceManager),
"otherarg"
),
new LocalizableResourceString(
@"Resource1",
resourceManager,
typeof(CustomResourceManager)
)
);
EqualityUtil.RunAll(unit, checkIEquatable: false);
var str = new LocalizableResourceString(
@"ResourceWithArguments",
resourceManager,
typeof(CustomResourceManager),
"arg"
);
var threw = false;
str.OnException += (sender, e) =>
{
threw = true;
};
Assert.False(str.Equals(42));
Assert.False(str.Equals(42));
Assert.False(threw);
}
public void Equality()
{
EqualityUtil.RunAll(
(left, right) => left == right,
(left, right) => left != right,
false,
true,
EqualityUnit.Create(CreateOne('a')).WithEqualValues(CreateOne('a')),
EqualityUnit.Create(CreateOne('a')).WithNotEqualValues(CreateOne('b')),
EqualityUnit.Create(CreateOne('a')).WithEqualValues(CreateMany('a')),
EqualityUnit.Create(CreateOne('D')).WithEqualValues(KeyNotationUtil.StringToKeyInputSet("D")),
EqualityUnit.Create(KeyInputSet.NewOneKeyInput(KeyInputUtil.CharToKeyInput('D'))).WithEqualValues(KeyNotationUtil.StringToKeyInputSet("D")));
}
public void Equality5()
{
var values = EqualityUnit
.Create(KeyInputUtil.CharToKeyInput('c'))
.WithEqualValues(KeyInputUtil.CharToKeyInput('c'))
.WithNotEqualValues(KeyInputUtil.CharToKeyInput('d'))
.WithNotEqualValues(KeyInputUtil.CharWithControlToKeyInput('c'));
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
values: values);
}
public void Equals3()
{
var value = EqualityUnit
.Create(new KeyStroke(KeyInputUtil.CharToKeyInput('c'), KeyModifiers.None))
.WithEqualValues(new KeyStroke(KeyInputUtil.CharToKeyInput('c'), KeyModifiers.None))
.WithNotEqualValues(new KeyStroke(KeyInputUtil.CharToKeyInput('d'), KeyModifiers.None))
.WithNotEqualValues(new KeyStroke(KeyInputUtil.CharToKeyInput('c'), KeyModifiers.Shift));
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
values: value);
}
public void Guids()
{
var guid = Guid.NewGuid();
var unit = EqualityUnit
.Create(new CommandId(guid, 42))
.WithEqualValues(new CommandId(guid, 42))
.WithNotEqualValues(new CommandId(Guid.NewGuid(), 42));
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
unit);
}
public void Equality1()
{
EqualityUtil.RunAll(
(left, right) => object.Equals(left, right),
(left, right) => !object.Equals(left, right),
EqualityUnit.Create(new FileLinePositionSpan("C:\\goo.cs", new LinePosition(1, 2), new LinePosition(3, 5)))
.WithNotEqualValues(new FileLinePositionSpan("C:\\Goo.cs", new LinePosition(1, 2), new LinePosition(3, 5))),
EqualityUnit.Create(new FileLinePositionSpan("C:\\goo.cs", new LinePosition(1, 2), new LinePosition(3, 5)))
.WithNotEqualValues(new FileLinePositionSpan("C:\\bar.cs", new LinePosition(1, 2), new LinePosition(3, 5))),
EqualityUnit.Create(new FileLinePositionSpan("C:\\goo.cs", new LinePosition(1, 2), new LinePosition(3, 5)))
.WithNotEqualValues(new FileLinePositionSpan("C:\\goo.cs", new LinePosition(1, 4), new LinePosition(3, 5))),
EqualityUnit.Create(new FileLinePositionSpan("C:\\goo.cs", new LinePosition(1, 2), new LinePosition(3, 5)))
.WithNotEqualValues(new FileLinePositionSpan("C:\\goo.cs", new LinePosition(1, 2), new LinePosition(4, 5))));
}
public void Equality1()
{
var value = EqualityUnit
.Create(KeyBinding.Parse("::b"))
.WithEqualValues(KeyBinding.Parse("::b"))
.WithNotEqualValues(KeyBinding.Parse("local::b"))
.WithNotEqualValues(KeyBinding.Parse("::Shift+b"))
.WithNotEqualValues(KeyBinding.Parse("::Left Arrow"));
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
values: value);
}
public void KeyBindings()
{
var id = new CommandId(Guid.NewGuid(), 42);
var keyBinding1 = KeyBinding.Parse("Global::Enter");
var keyBinding2 = KeyBinding.Parse("Global::h");
EqualityUtil.RunAll(
(left, right) => left == right,
(left, right) => left != right,
false,
false,
EqualityUnit.Create(new CommandKeyBinding(id, "Test", keyBinding1))
.WithEqualValues(new CommandKeyBinding(id, "Test", keyBinding1))
.WithNotEqualValues(new CommandKeyBinding(id, "Test", keyBinding2)));
}
public void CommandId()
{
var id1 = new CommandId(Guid.NewGuid(), 42);
var id2 = new CommandId(id1.Group, 13);
var id3 = new CommandId(Guid.NewGuid(), 42);
var keyBinding = KeyBinding.Parse("Global::Enter");
EqualityUtil.RunAll(
(left, right) => left == right,
(left, right) => left != right,
false,
false,
EqualityUnit.Create(new CommandKeyBinding(id1, "Test", keyBinding))
.WithEqualValues(new CommandKeyBinding(id1, "Test", keyBinding))
.WithNotEqualValues(new CommandKeyBinding(id2, "Test", keyBinding))
.WithNotEqualValues(new CommandKeyBinding(id3, "Test", keyBinding)));
}
public void EqualsTargetTypeSameObject()
{
var ref1 = CreateEqualsInterface <ITypeReference>("ref1");
var ref2 = CreateEqualsInterface <ITypeReference>("ref2");
var value = UsedNamespaceOrType.CreateType(ref1.Object, "alias");
var unit = EqualityUnit
.Create(value)
.WithEqualValues(
value,
UsedNamespaceOrType.CreateType(ref1.Object, "alias"))
.WithNotEqualValues(
UsedNamespaceOrType.CreateNamespace(new Mock <INamespace>().Object),
UsedNamespaceOrType.CreateType(ref2.Object, "alias"),
UsedNamespaceOrType.CreateType(ref1.Object, "different alias"));
RunAll(unit);
}
private static void RunAll(EqualityUnit<BoundBuildId> unit)
{
unit.RunAll(
compEqualsOperator: (x, y) => x == y,
compNotEqualsOperator: (x, y) => x != y);
}
private void Run(EqualityUnit<CharSpan> equalityUnit)
{
EqualityUtil.RunAll(equalityUnit);
}
private static void RunAll(EqualityUnit <UsedNamespaceOrType> unit)
{
EqualityUtil.RunAll(unit);
}
static EqualityUnit <LineMapping> CreateEqualityUnit(LineMapping left, int leftIndex, LineMapping right, int rightIndex)
{
var leftUnit = EqualityUnit.Create(left);
return((leftIndex == rightIndex) ? leftUnit.WithEqualValues(right) : leftUnit.WithNotEqualValues(right));
}