В чем разница между Assert.AreNotEqual и утверждают.Разве не так?

Question

В чем разница между Assert.AreNotEqual и утверждают.Разве не так?

В C#, в чем разница между

Assert.AreNotEqual

и

Assert.AreNotSame

745 6

unit-testing c#.net assert testing

6 ответов:

Comments

Ничего не найдено.

Jon Skeet · Accepted Answer · 2017-05-23 14:46:51

почти все ответы, приведенные здесь, верны, но, вероятно, стоит привести пример:
public static string GetSecondWord(string text)
{
    // Yes, an appalling implementation...
    return text.Split(' ')[1];
}

string expected = "world";
string actual = GetSecondWord("hello world");

// Good: the two strings should be *equal* as they have the same contents
Assert.AreEqual(expected, actual);

// Bad: the two string *references* won't be the same
Assert.AreSame(expected, actual);
AreNotEqual и AreNotSame это просто инверсии AreEqual и AreSame конечно.

EDIT: опровержение к в настоящее время принимаются ответ...

если вы используете Assert.AreSame С типами значений, они упаковываются. Другими словами, это эквивалентно делать:
int firstNumber = 1;
int secondNumber = 1;
object boxedFirstNumber = firstNumber;
object boxedSecondNumber = secondNumber;

// There are overloads for AreEqual for various value types
// (assuming NUnit here)
Assert.AreEqual(firstNumber, secondNumber);

// ... but not for AreSame, as it's not intended for use with value types
Assert.AreSame(boxedFirstNumber, boxedSecondNumber);
ни firstNumber, ни secondNumber имеет значение объекта, потому что int тип значения. Причина тому AreSame вызов завершится неудачей, потому что в .NET, бокс значение создает новое поле каждый раз. (В Java это иногда не так - это поймало меня раньше.)

в основном вы должны никогда использовать AreSame при сравнении типов значений. Когда вы сравниваете ссылка типы, использовать AreSame если вы хотите проверить идентичные ссылки; используйте AreEqual чтобы проверить эквивалентность под Equals. Изменить: обратите внимание, что там are ситуации, когда NUnit не просто использует Equals непосредственно; он имеет встроенную поддержку коллекций, где элементы в коллекциях проверяются на равенство.

претензия в ответе что:

используя пример выше изменения int to string, AreSame и AreEqual возвращать то же самое значение.

полностью зависит от того, как инициализируются переменные. Если они используют строковые литералы, то тем не менее, интернирование позаботится об этом. Если, однако, вы используете:
string firstString = 1.ToString();
string secondString = 1.ToString();
тогда AreSame и AreEqual будет почти наверняка не возвращает то же значение.

для:

общее эмпирическое правило использовать AreEqual на типах значений и AreSame на ссылочный тип.

я почти никогда хотите проверить Для справки, удостоверяющий личность. Это редко бывает полезно для меня. Я хочу проверить эквивалентности что AreEqual проверка. (Я не говорю, что AreSame не должно быть там - это полезный метод, просто гораздо реже, чем AreEqual.)

Godeke · Accepted Answer · 2009-02-13 01:26:28

две вещи могут быть равны, но разные объекты. AreNotEqual проверяет объекты значения через тест равенства, в то время как AreNotSame проверяет, что они не являются одним и тем же точным объектом.

очевидно, почему мы хотели бы проверить, что вещи AreNotEqual (мы заботимся о проверяемых значениях); как насчет AreNotSame? Полезность этого в тестировании обнаруживается, когда вы передали ссылки вокруг и хотите убедиться, что после вашего перетасовки сделано, что два ссылки-это все тот же объект.

в реальном мире, мы используем много объектов кэширования для смягчения туда и обратно в базу данных. После того, как объект был передан в систему кэша, наши модульные тесты гарантируют, что в некоторых случаях мы возвращаем тот же объект (Кэш был действителен), а в других случаях мы возвращаем свежие объект (Кэш был признан недействительным). Обратите внимание, что AreNotEqual не будет достаточно в этом случае. Если объект имел новую метку времени в базе данных, и все же data не было "достаточно разных", чтобы провалить тест на равенство, AreNotEqual не заметил бы, что мы обновили объект.

ermau · Accepted Answer · 2009-02-12 23:11:17

AreNotSame не сравнение, а AreNotEqual выполняет сравнение на равенство.

Ole Lynge · Accepted Answer · 2009-02-12 23:33:42

утверждать.AreNotEqual утверждает, что два значения не равны друг другу.

утверждать.AreNotSame утверждает, что две переменные не указывают на один и тот же объект.

Пример 1:
int i = 1;
int j = i;
// The values are equal:
Assert.AreEqual(i, j);
// Two value types do *not* represent the same object:
Assert.AreNotSame(i, j);
Пример 2:
string s = "A";
string t = s;
// The values are equal:
Assert.AreEqual(s, t);
// Reference types *can* point to the same object:
Assert.AreSame(s, t);

Marc Gravell · Accepted Answer · 2009-02-12 23:11:34

AreNotSame использует равенство ссылок (object.ReferenceEquals) - т. е. являются ли они одним и тем же фактическим экземпляром объекта; AreNotEqual использует концептуальное равенство (.Equals) - т. е. считается равны.

Antti Huima · Accepted Answer · 2009-02-12 23:13:06

Не так ли, что AreNotEqual проверяет случай, когда два объекта не равны в терминах метода Equals (), тогда как AreNotSame проверяет случай, когда две ссылки на объекты не совпадают. Поэтому, если x и y являются двумя объектами, которые равны в терминах Equals (), но были отдельно выделены, AreNotEqual() вызовет неудачное утверждение, но другое нет.