| public static AreNotEqual ( object objA, object objB ) : bool | ||
| objA | object | |
| objB | object | |
| return | bool | |
protected async Task MembershipTable_ReadAll_Insert_ReadAll()
{
MembershipTableData data = await membershipTable.ReadAll();
logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", data.Version, data);
Assert.AreEqual(0, data.Members.Count, "Number of records returned - no table version row");
TableVersion newTableVersion = data.Version.Next();
MembershipEntry newEntry = CreateMembershipEntryForTest();
bool ok = await membershipTable.InsertRow(newEntry, newTableVersion);
Assert.IsTrue(ok, "InsertRow failed");
data = await membershipTable.ReadAll();
logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", data.Version, data);
Assert.AreEqual(1, data.Members.Count, "Number of records returned - data row only");
Assert.IsNotNull(data.Version.VersionEtag, "New version ETag should not be null");
Assert.AreNotEqual(newTableVersion.VersionEtag, data.Version.VersionEtag, "New VersionEtag differetnfrom last");
Assert.AreEqual(newTableVersion.Version, data.Version.Version);
MembershipEntry MembershipEntry = data.Members[0].Item1;
string eTag = data.Members[0].Item2;
logger.Info("Membership.ReadAll returned MembershipEntry ETag={0} Entry={1}", eTag, MembershipEntry);
Assert.IsNotNull(eTag, "ETag should not be null");
Assert.IsNotNull(MembershipEntry, "MembershipEntry should not be null");
}
public void Test_Where_You_Expect_That_Reference_Objects_Will_Affect_Each_Other()
{
var myReferenceTypeClass = new ReferenceTypeClass();
myReferenceTypeClass.Name = "pies";
var myReferenceTypeClassCopy = myReferenceTypeClass;
myReferenceTypeClassCopy.Name = "wilk";
Assert.AreEqual(myReferenceTypeClass.Name, myReferenceTypeClassCopy.Name);
var myValueTypeClass = new ValueTypesInClass();
myValueTypeClass.X_Value = 1;
myValueTypeClass.Y_Value = myValueTypeClass.X_Value;
var copy = myValueTypeClass;
copy.X_Value = 3;
Assert.AreEqual(myValueTypeClass.X_Value, copy.X_Value);
Assert.AreNotEqual(myValueTypeClass.X_Value, copy.Y_Value);
var isItTrue = myValueTypeClass.Equals(copy);
Assert.IsTrue(isItTrue);
}
public void Inequality()
{
int expectedValue = 3;
int actualValue = 3;
// MSTest
MSTestAssert.AreNotEqual(expectedValue, actualValue, "Some context");
// Assert.AreNotEqual failed. Expected any value except:<3>. Actual:<3>. Some context
// NUnit
Assert.That(actualValue, Is.Not.EqualTo(expectedValue), () => "Some context");
// Some context
// Expected: not equal to 3
// But was: 3
// XUnit
XUnitAssert.NotEqual(expectedValue, actualValue);
// Assert.NotEqual() Failure
// Expected: Not 3
// Actual: 3
// Fluent
actualValue.Should().NotBe(expectedValue, "SOME REASONS");
// Did not expect actualValue to be 3 because SOME REASONS.
// Shouldly
actualValue.ShouldNotBe(expectedValue, "Some context");
// actualValue
// should not be
// 3
// but was
//
// Additional Info:
// Some context
}
public void ApproximateInequalityOfFloatingPointNumbers()
{
double pi = 3.14;
// MSTest
MSTestAssert.AreNotEqual(Math.PI, pi, 0.01, "Some context");
// Assert.AreNotEqual failed. Expected a difference greater than <0.01> between expected value <3.14159265358979> and actual value <3.14>. Some context
// NUnit
Assert.That(pi, Is.Not.EqualTo(Math.PI).Within(0.1).Percent, () => "Some context");
// Some context
// Expected: not equal to 3.1415926535897931d +/- 0.10000000000000001d Percent
// But was: 3.1400000000000001d
// XUnit
XUnitAssert.NotEqual(Math.PI, pi, 1);
// Message: Assert.NotEqual() Failure
// Expected: Not 3.1 (rounded from 3.14159265358979)
// Actual: 3.1 (rounded from 3.14)
// Fluent
pi.Should().NotBeApproximately(Math.PI, 0.01, "SOME REASONS");
// Expected pi to not approximate 3.1415926535897931 +/- 0.01 because SOME REASONS, but 3.14 only differed by 0.001592653589793223.
// Shouldly does not support this case.
}
public void TestRuleReadWriterWriteWithExportAll()
{
var parsed = new Args
{
ServerName = "WRK-003",
DbName = "BizTalkRuleEngineDb",
Mode = Mode.ExportAll,
IsOverwrite = true,
Path = @"C:\Users\v.michailov\RealProjects\biztalkutilites\inputData"
};
Assert.AreEqual(false, File.Exists(@"..\..\..\inputData\Policy.Test-1.0.xml"));
Assert.AreEqual(false, File.Exists(@"..\..\..\inputData\Policy.Test-1.1.xml"));
Assert.AreEqual(false, File.Exists(@"..\..\..\inputData\PolicyAA-1.0.xml"));
Assert.AreEqual(false, File.Exists(@"..\..\..\inputData\voc1-1.0.xml"));
Assert.AreEqual(false, File.Exists(@"..\..\..\inputData\voc2-1.0.xml"));
RuleReadWriter.Write(parsed.ServerName, parsed.DbName, parsed.RuleNames, parsed.Path, TODO);
var timeBefore1 = File.GetLastAccessTime(@"..\..\..\inputData\Policy.Test-1.0.xml");
var timeBefore2 = File.GetLastAccessTime(@"..\..\..\inputData\voc2-1.0.xml");
RuleReadWriter.Write(parsed.ServerName, parsed.DbName, parsed.RuleNames, parsed.Path, TODO);
var timeAfter1 = File.GetLastAccessTime(@"..\..\..\inputData\Policy.Test-1.0.xml");
var timeAfter2 = File.GetLastAccessTime(@"..\..\..\inputData\voc2-1.0.xml");
Assert.AreNotEqual(timeBefore1.Millisecond, timeAfter1.Millisecond);
Assert.AreNotEqual(timeBefore2.Millisecond, timeAfter2.Millisecond);
Assert.AreEqual(true, File.Exists(@"..\..\..\inputData\Policy.Test-1.0.xml"));
Assert.AreEqual(true, File.Exists(@"..\..\..\inputData\Policy.Test-1.1.xml"));
Assert.AreEqual(true, File.Exists(@"..\..\..\inputData\PolicyAA-1.0.xml"));
Assert.AreEqual(true, File.Exists(@"..\..\..\inputData\voc1-1.0.xml"));
Assert.AreEqual(true, File.Exists(@"..\..\..\inputData\voc2-1.0.xml"));
}
public void CheckObsoleteGenerateFunction()
{
var path = PythonPaths.Versions.LastOrDefault(p => p != null && p.IsCPython);
path.AssertInstalled();
var factory = InterpreterFactoryCreator.CreateInterpreterFactory(new InterpreterFactoryCreationOptions {
Id = path.Id,
LanguageVersion = path.Version.ToVersion(),
Description = "Test Interpreter",
Architecture = path.Isx64 ? ProcessorArchitecture.Amd64 : ProcessorArchitecture.X86,
LibraryPath = path.LibPath,
PrefixPath = path.PrefixPath,
InterpreterPath = path.InterpreterPath,
WatchLibraryForNewModules = false
});
var tcs = new TaskCompletionSource <int>();
var beforeProc = Process.GetProcessesByName("Microsoft.PythonTools.Analyzer");
var request = new PythonTypeDatabaseCreationRequest {
Factory = factory,
OutputPath = TestData.GetTempPath(randomSubPath: true),
SkipUnchanged = true,
OnExit = tcs.SetResult
};
Console.WriteLine("OutputPath: {0}", request.OutputPath);
#pragma warning disable 618
PythonTypeDatabase.Generate(request);
#pragma warning restore 618
int expected = 0;
if (!tcs.Task.Wait(TimeSpan.FromMinutes(1.0)))
{
var proc = Process.GetProcessesByName("Microsoft.PythonTools.Analyzer")
.Except(beforeProc)
.ToArray();
// Ensure we actually started running
Assert.AreNotEqual(0, proc.Length, "Process is not running");
expected = -1;
// Kill the process
foreach (var p in proc)
{
Console.WriteLine("Killing process {0}", p.Id);
p.Kill();
}
Assert.IsTrue(tcs.Task.Wait(TimeSpan.FromMinutes(1.0)), "Process did not die");
}
Assert.AreEqual(expected, tcs.Task.Result, "Incorrect exit code");
}
public void InitReindexer()
{
_rx = ReindexerBinding.init_reindexer();
Assert.AreNotEqual(UIntPtr.Zero, _rx);
_logWriter = new LogWriterAction(Log);
ReindexerBinding.reindexer_enable_logger(_logWriter);
Connect();
}
public void ErrorTest()
{
var excp = Assert.ThrowsException <ReindexerException>(() =>
{
Client.DropNamespace(Guid.NewGuid().ToString());
});
Assert.AreNotEqual(ReindexerErrorCode.OK, excp?.ErrorCode);
}
public void SetStorageConfigsTest()
{
ServerSyncMessage m;
List <DtStorageConfig> storageConfigs;
// 正常系
{
m = new ServerSyncMessage();
storageConfigs = new List <DtStorageConfig>();
DtStorageConfig config = CreateStorageConfig("TestA", "UrlA", "SasA");
storageConfigs.Add(config);
config = CreateStorageConfig("TestB", "UrlB", "SasB");
storageConfigs.Add(config);
bool result = m.SetStorageConfigs(storageConfigs);
string message = ServerSyncMessage.CreateJsonString(m);
Assert.AreEqual(2, m.Storage.Count);
Assert.AreEqual(true, result);
Assert.IsNotNull(m.Script);
Assert.IsNotNull(m.Storage);
Assert.IsNotNull(message);
Assert.AreNotEqual(string.Empty, message);
}
// nullを設定したケース
{
m = new ServerSyncMessage();
storageConfigs = new List <DtStorageConfig>();
bool result = m.SetStorageConfigs(null);
string message = ServerSyncMessage.CreateJsonString(m);
Assert.AreEqual(false, result);
Assert.IsNotNull(m.Script);
Assert.IsNotNull(m.Storage);
Assert.IsNotNull(message);
Assert.AreNotEqual(string.Empty, message);
}
// 空のリストを設定したケース
{
m = new ServerSyncMessage();
storageConfigs = new List <DtStorageConfig>();
bool result = m.SetStorageConfigs(storageConfigs);
string message = ServerSyncMessage.CreateJsonString(m);
Assert.AreEqual(true, result);
Assert.IsNotNull(m.Script);
Assert.IsNotNull(m.Storage);
Assert.IsNotNull(message);
Assert.AreNotEqual(string.Empty, message);
}
}
public void TestProps_Void_Ok()
{
var derived = new DerivedClass();
var param = new OtherClass();
Assert.AreNotEqual("done", param.PublicStringProp);
derived.InvokeMethod("AVoidMethod", param);
Assert.AreEqual("done", param.PublicStringProp);
}
public void TestGetDaysInYear()
{
/* positive testing */
var testValue = new DateTime(2010, 1, 1);
var resultValue = 365;
Assert.AreEqual(testValue.GetDays(), resultValue);
/* negative testing */
testValue = new DateTime(2012, 1, 1);
Assert.AreNotEqual(testValue.GetDays(), resultValue);
}
public void CheckObsoleteGenerateFunction()
{
var path = PythonPaths.Versions.LastOrDefault(p => p != null && p.IsCPython);
path.AssertInstalled();
var factory = InterpreterFactoryCreator.CreateInterpreterFactory(path.Configuration) as PythonInterpreterFactoryWithDatabase;
if (factory == null)
{
Assert.Inconclusive("Test requires PythonInterpreterFactoryWithDatabase");
}
var tcs = new TaskCompletionSource <int>();
var beforeProc = Process.GetProcessesByName("Microsoft.PythonTools.Analyzer");
var request = new PythonTypeDatabaseCreationRequest {
Factory = factory,
OutputPath = TestData.GetTempPath(),
SkipUnchanged = true,
OnExit = tcs.SetResult
};
Console.WriteLine("OutputPath: {0}", request.OutputPath);
#pragma warning disable 618
PythonTypeDatabase.Generate(request);
#pragma warning restore 618
int expected = 0;
if (!tcs.Task.Wait(TimeSpan.FromMinutes(1.0)))
{
var proc = Process.GetProcessesByName("Microsoft.PythonTools.Analyzer")
.Except(beforeProc)
.ToArray();
// Ensure we actually started running
Assert.AreNotEqual(0, proc.Length, "Process is not running");
expected = -1;
// Kill the process
foreach (var p in proc)
{
Console.WriteLine("Killing process {0}", p.Id);
p.Kill();
}
Assert.IsTrue(tcs.Task.Wait(TimeSpan.FromMinutes(1.0)), "Process did not die");
}
Assert.AreEqual(expected, tcs.Task.Result, "Incorrect exit code");
}
public void DropNamespace()
{
var error = ReindexerBinding.reindexer_drop_namespace(_rx, "DropNamespaceTest".GetHandle(), _ctxInfo);
Assert.AreNotEqual(0, error.code);
AssertError(ReindexerBinding.reindexer_open_namespace(_rx, "DropNamespaceTest".GetHandle(),
new StorageOpts {
options = StorageOpt.kStorageOptCreateIfMissing | StorageOpt.kStorageOptEnabled
},
_ctxInfo));
AssertError(ReindexerBinding.reindexer_drop_namespace(_rx, "DropNamespaceTest".GetHandle(), _ctxInfo));
}
public void GetHashCodeTest()
{
JobParameters jp = TearUp();
JobParameters jpCo = TearUp();
JobParameters jp2 = new JobParameters();
int hc = jp.GetHashCode();
int hcCo = jpCo.GetHashCode();
int hc2 = jp2.GetHashCode();
Assert.AreNotEqual(hc, hcCo);
Assert.AreNotEqual(hc, hc2);
}
public void Test_Where_You_Expect_That_Value_Object_Will_Not_Affect_Each_Other()
{
var myValueTypeClass = new ValueTypesInClass();
myValueTypeClass.X_Value = 1;
myValueTypeClass.Y_Value = myValueTypeClass.X_Value;
Assert.AreEqual(myValueTypeClass.X_Value, myValueTypeClass.Y_Value);
myValueTypeClass.X_Value = 2;
Assert.AreNotEqual(myValueTypeClass.X_Value, myValueTypeClass.Y_Value);
}
public void ShoudlReturnDifferentHashedPassword()
{
// Arrange
var service = new PasswordService();
var salt = new byte[] { 97, 155, 86, 162, 177, 155, 41, 91, 174, 20 };
const string password = "******";
const string hashedPassword = "******";
// Act
var result = service.CreateSaltedPasswordHash(password, salt);
// Assert
Assert.AreNotEqual(hashedPassword, result);
}
public void EqualsAndHashCode()
{
OverrideGHC a1 = new OverrideGHC(1, true);
OverrideGHC a2 = new OverrideGHC(1, true);
NotOverrideGHC b1 = new NotOverrideGHC(1, true);
NotOverrideGHC b2 = new NotOverrideGHC(1, true);
//if objects == than their hash codes match
A.IsTrue(a1.Equals(a2));
A.AreEqual(a1.GetHashCode(), a2.GetHashCode());
//default implementation do not satisfies rule above
A.IsTrue(b1.Equals(b2));
A.AreNotEqual(b1.GetHashCode(), b2.GetHashCode());
}
public void TestObjectWithLogger()
{
var tester = GetBaseTest();
var testObject = tester.TestObject;
var newTestObject = new BaseTestObject(testObject.Log, "TEST");
MicroAssert.AreEqual(testObject.Log, newTestObject.Log);
MicroAssert.AreNotEqual(testObject.SoftAssert, newTestObject.SoftAssert);
MicroAssert.AreEqual("TEST", newTestObject.PerfTimerCollection.TestName);
MicroAssert.AreNotEqual(testObject.PerfTimerCollection, newTestObject.PerfTimerCollection);
MicroAssert.AreNotEqual(testObject.Values, newTestObject.Values);
MicroAssert.AreNotEqual(testObject.Objects, newTestObject.Objects);
MicroAssert.AreNotEqual(testObject.ManagerStore, newTestObject.ManagerStore);
MicroAssert.AreNotEqual(testObject.AssociatedFiles, newTestObject.AssociatedFiles);
}
public void EqualsTestWithEmpty()
{
ServerSyncMessage m = new ServerSyncMessage();
List <DtScriptConfig> scriptConfigs = new List <DtScriptConfig>();
List <DtStorageConfig> storageConfigs = new List <DtStorageConfig>();
m.SetScriptConfigs(scriptConfigs);
m.SetStorageConfigs(storageConfigs);
string message = ServerSyncMessage.CreateJsonString(m);
Assert.IsNotNull(message);
Assert.AreNotEqual(string.Empty, message);
Assert.IsNotNull(m.Script);
Assert.IsNotNull(m.Storage);
}
public void Inheritance()
{
string code = @"
class WithInstanceMembers(object):
def __init__(self):
self.fob = 42
class WithMemberFunctions(object):
def oar(self):
pass
class SingleInheritance(WithMemberFunctions):
def baz(self):
pass
class DoubleInheritance(SingleInheritance):
pass
class MultipleInheritance(WithInstanceMembers, WithMemberFunctions):
pass
";
using (var newPs = SaveLoad(PythonLanguageVersion.V27, new AnalysisModule("test", "test.py", code))) {
AssertUtil.Contains(newPs.Analyzer.Analyzer.GetModules().Select(x => x.Name), "test");
string codeText = @"
import test
WithInstanceMembers = test.WithInstanceMembers
WithMemberFunctions = test.WithMemberFunctions
SingleInheritance = test.SingleInheritance
DoubleInheritance = test.DoubleInheritance
MultipleInheritance = test.MultipleInheritance
";
var newMod = newPs.NewModule("baz", codeText);
int pos = codeText.LastIndexOf('\n');
// instance attributes are present
var instMembers = newMod.Analysis.GetMembersByIndex("WithInstanceMembers", pos);
var fobMembers = instMembers.Where(x => x.Name == "fob");
Assert.AreNotEqual(null, fobMembers.FirstOrDefault().Name);
newPs.Analyzer.AssertHasAttr("WithMemberFunctions", "oar");
newPs.Analyzer.AssertHasAttr("SingleInheritance", "oar", "baz");
newPs.Analyzer.AssertHasAttr("DoubleInheritance", "oar", "baz");
newPs.Analyzer.AssertHasAttr("MultipleInheritance", "fob", "oar");
}
}
public void SaveManyTest()
{
var list = new List <Article> {
article.Clone(), article.Clone(), article.Clone(), article.Clone(), article.Clone(), article.Clone(), article.Clone(),
};
var stopWatch = new Stopwatch();
stopWatch.Start();
list = rep.SaveMany(list).ToList();
stopWatch.Stop();
Console.WriteLine(stopWatch.ElapsedMilliseconds);
foreach (var i in list)
{
Assert.AreNotEqual(0, i.ArticleId);
Assert.AreNotEqual(-1, i.ArticleId);
}
}
public void ShouldRefreshMainContainerMarginsAdjustBackButtonVisibility()
{
//arrange
viewModel = new MockBaseViewModel();
//act
DeviceManager.Idiom = Devices.Tablet.ToString();
DeviceManager.Orientation = Devices.Landscape.ToString();
bool originalVisibility = viewModel.ShouldBackButtonBeHidden;
DeviceManager.Orientation = Devices.Portrait.ToString();
viewModel.RefreshMainContainerMargins();
bool modifiedVisibility = viewModel.ShouldBackButtonBeHidden;
//assert
Assert.AreNotEqual(originalVisibility, modifiedVisibility);
}
public void TestEnumModules()
{
using (var app = new VisualStudioApp()) {
StartHelloWorldAndBreak(app);
var modules = ((Process3)app.Dte.Debugger.CurrentProcess).Modules;
Assert.IsTrue(modules.Count >= 1);
var module = modules.Item("Program");
Assert.IsNotNull(module);
Assert.IsTrue(module.Path.EndsWith("Program.py"));
Assert.AreEqual("Program", module.Name);
Assert.AreNotEqual((uint)0, module.Order);
app.Dte.Debugger.TerminateAll();
WaitForMode(app, dbgDebugMode.dbgDesignMode);
}
}
public void NotOverrideGHCInCollection()
{
String va, vb;
var a = new NotOverrideGHC(1, true);
var b = new NotOverrideGHC(1, true);
var d = new Dictionary <NotOverrideGHC, String>();
d.Add(a, "a1 value");
d.TryGetValue(a, out va);
d.TryGetValue(b, out vb);
//without overrided hash code if objects are equal could not find them in hash table
//find only by instanse
A.AreEqual(a, b);
A.AreEqual("a1 value", va);
A.AreNotEqual("a1 value", vb);
}
public void TestRandom()
{
var list = new List <string>();
list.Add("BorgeJ");
list.Add("Rob");
list.Add("Tom");
list.Add("Don");
list.Add("Ricky");
var randomlist = Randomize(list);
foreach (var elem in randomlist)
{
Console.Write(elem);
}
Assert.AreNotEqual(list, randomlist);
}
public void SelectSql()
{
ModifyItemPacked();
var rsp = ReindexerBinding.reindexer_select(_rx,
$"SELECT * FROM {DataTestNamespace}".GetHandle(),
1, new int[0], 0, _ctxInfo);
if (rsp.err_code != 0)
{
Assert.AreEqual(null, (string)rsp.@out);
}
Assert.AreNotEqual(UIntPtr.Zero, [email protected]_ptr);
var(json, offsets, explain) = BindingHelpers.RawResultToJson(rsp.@out, "items", "total_count");
Assert.AreNotEqual(0, json.Length);
Assert.AreNotEqual(0, offsets.Count);
}
public void ShouldRefreshMainContainerMarginsAdjustLeftIconVisibility()
{
//arrange
viewModel = new MockBaseViewModel();
//act
DeviceManager.Version = "13.3";
DeviceManager.Platform = Devices.iOS.ToString();
DeviceManager.Orientation = Devices.Landscape.ToString();
App.ScreenHeight = 960;
App.ScreenWidth = 640;
bool originalVisibility = viewModel.IsLeftIconVisible;
DeviceManager.Orientation = Devices.Portrait.ToString();
viewModel.RefreshMainContainerMargins();
bool modifiedVisibility = viewModel.IsLeftIconVisible;
//assert
Assert.AreNotEqual(originalVisibility, modifiedVisibility);
}
public void ShouldRefreshMainContainerMarginsAdjustGetMainContainerMargin()
{
//arrange
viewModel = new MockBaseViewModel();
//act
DeviceManager.Version = "13.3";
DeviceManager.Platform = Devices.iOS.ToString();
DeviceManager.Idiom = Devices.Phone.ToString();
DeviceManager.Orientation = Devices.Landscape.ToString();
App.ScreenHeight = 1334;
App.ScreenWidth = 750;
Thickness originalMargin = viewModel.GetMainContainerMargin;
DeviceManager.Orientation = Devices.Portrait.ToString();
viewModel.RefreshMainContainerMargins();
Thickness modifiedMargin = viewModel.GetMainContainerMargin;
//assert
Assert.AreNotEqual(modifiedMargin, originalMargin);
}
public void TestMethod1()
{
var a = "";
var b = 100;
object o1 = 1;
object o2 = a;
object o3 = new { z = "23", e = 1 };
object o4 = new { z1 = "", e1 = 8 };
Console.WriteLine("a: " + a.GetType().ToString());
Console.WriteLine("b: " + b.GetType().ToString());
Console.WriteLine("o1: " + o1.GetType().ToString());
Console.WriteLine("o1 long: " + ((long)(int)o1).GetType().ToString());
Console.WriteLine("o2: " + o2.GetType().ToString());
Console.WriteLine("o3: " + o3.GetType().ToString());
Console.WriteLine("o4: " + o4.GetType().ToString());
A.AreEqual(typeof(String), a.GetType());
A.AreEqual(typeof(int), b.GetType());
A.AreNotEqual(o3.GetType(), o4.GetType());
}
public void DeleteSql()
{
AssertError(ReindexerBinding.reindexer_open_namespace(_rx, DataTestNamespace.GetHandle(),
new StorageOpts {
options = StorageOpt.kStorageOptCreateIfMissing | StorageOpt.kStorageOptEnabled
},
_ctxInfo));
ModifyItemPacked($"{{\"Id\":2, \"Guid\":\"{Guid.NewGuid()}\"}}");
var delRsp = ReindexerBinding.reindexer_select(_rx,
$"DELETE FROM {DataTestNamespace} WHERE Id=2".GetHandle(),
1, new int[0], 0, _ctxInfo);
if (delRsp.err_code != 0)
{
Assert.AreEqual(null, (string)delRsp.@out);
}
Assert.AreNotEqual(UIntPtr.Zero, [email protected]_ptr);
var(json, offsets, explain) = BindingHelpers.RawResultToJson(delRsp.@out, "items", "total_count");
Assert.AreNotEqual(0, json.Length);
Assert.AreNotEqual(0, offsets.Count);
var selRsp = ReindexerBinding.reindexer_select(_rx,
$"SELECT * FROM {DataTestNamespace} WHERE Id=2".GetHandle(),
1, new int[] { 0 }, 1, _ctxInfo);
if (selRsp.err_code != 0)
{
Assert.AreEqual(null, (string)selRsp.@out);
}
Assert.AreNotEqual(UIntPtr.Zero, [email protected]_ptr);
(json, offsets, explain) = BindingHelpers.RawResultToJson(selRsp.@out, "items", "total_count");
Assert.AreNotEqual(0, json.Length);
Assert.AreEqual(0, offsets.Count);
}
