public void ShouldCancelTasksOnShutdown()
{
var executor = CreateDefaultExecutor(ShutdownMode.CancelQueuedTasks);
var tasks = new List<WaitingTask>();
var futures = new List<Future<int>>();
for(int i=0; i<10; i++) {
WaitingTask task = new WaitingTask();
tasks.Add(task);
if(i == 0) {
Monitor.Enter(task);
}
futures.Add(executor.Submit(task));
}
executor.Shutdown();
Monitor.Exit(tasks[0]);
while(!executor.IsShutdown()) { }
Assert.AreEqual(0, futures[0].GetResult());
foreach(Future<int> future in futures.GetRange(1, 9)) {
Assert.IsTrue(future.IsDone);
try {
Assert.AreEqual(0, future.GetResult());
Assert.Fail(); // Should not reach this
} catch(ExecutionException e) {
Assert.IsInstanceOfType(typeof(TaskCancelledException), e.delayedException);
}
}
}
public void Simple2()
{
var list = new List<int> { 1, 2, 3, 4, 7, 8 }; ;
IList<int> iList = list;
var listRange = list.GetRange(2, 3);
var iListRange = iList.GetRange(2, 3);
AssertListsAreTheSame(listRange, iListRange);
}
public void MoveTest()
{
int len = 2;
int step = 1;
int from = 1, to = 3;
var list1 = new List<string>
{
"ABABAB",
"ABATAT",
"TABABAB",
"ABTABAB",
"ABABAB",
"ABABAB",
"ABABAB"
};
List<string> list = list1.GetRange(@from, to - @from);
var chain = new ComplexChain(list1);
var iterator = new EndIterator(chain, len, step);
iterator.Move(2);
List<string> result = iterator.Next();
for (int i = 0; i < list.Count; i++)
{
Assert.True(list[i].Equals(result[i]));
}
}
public void TestTransferPaid()
{
var e = new StripeEvent
{
LiveMode = true,
Type = "transfer.paid",
Created = DateTime.Now.AddDays(-1),
Data = new StripeEventData
{
Object = JObject.FromObject(new StripeTransfer
{
Id = "tx9876",
Amount = 1443
})
}
};
var charges = new List<StripeCharge>
{
new StripeCharge
{
Id = "ch111",
Amount = 111,
Fee = 1,
Type = "charge"
},
new StripeCharge
{
Id = "ch222",
Amount = 222,
Fee = 2,
Type = "charge"
},
new StripeCharge
{
Id = "ch333",
Amount = 333,
Fee = 3,
Type = "charge"
},
new StripeCharge
{
Id = "ch777",
Amount = 777,
Fee = 7,
Type = "charge"
},
new StripeCharge
{
Id = "ch444",
Amount = 444,
Fee = 4,
Type = "charge"
},
new StripeCharge
{
Id = "ch555",
Amount = 555,
Fee = 5,
Type = "refund"
}
};
_donationService.Setup(mocked => mocked.GetDonationByProcessorPaymentId("ch111")).Returns(new DonationDTO
{
Id = "1111",
BatchId = null
});
_donationService.Setup(mocked => mocked.GetDonationByProcessorPaymentId("ch222")).Returns(new DonationDTO
{
Id = "2222",
BatchId = null
});
_donationService.Setup(mocked => mocked.GetDonationByProcessorPaymentId("ch333")).Returns(new DonationDTO
{
Id = "3333",
BatchId = null
});
_donationService.Setup(mocked => mocked.GetDonationByProcessorPaymentId("ch444")).Throws(new Exception("Not gonna do it, wouldn't be prudent."));
_paymentService.Setup(mocked => mocked.GetChargeRefund("ch555")).Returns(new StripeRefund
{
Data = new List<StripeRefundData>
{ new StripeRefundData()
{
Id = "ch555",
Amount = "987",
Charge = new StripeCharge {
Id = "re_123456"
}
}
}
});
_donationService.Setup(mocked => mocked.GetDonationByProcessorPaymentId("ch555")).Returns(new DonationDTO
{
Id = "5555",
BatchId = 1984
});
_donationService.Setup(mocked => mocked.GetDonationBatch(1984)).Returns(new DonationBatchDTO
{
Id = 5150,
ProcessorTransferId = "OU812"
});
_donationService.Setup(mocked => mocked.GetDonationByProcessorPaymentId("ch777")).Returns(new DonationDTO
{
Id = "7777",
BatchId = 2112
});
_donationService.Setup(mocked => mocked.GetDonationBatch(2112)).Returns(new DonationBatchDTO
{
Id = 2112,
ProcessorTransferId = null
});
_donationService.Setup(mocked => mocked.GetDonationBatchByProcessorTransferId("tx9876")).Returns((DonationBatchDTO)null);
_paymentService.Setup(mocked => mocked.GetChargesForTransfer("tx9876")).Returns(charges);
_donationService.Setup(
mocked => mocked.CreatePaymentProcessorEventError(e, It.IsAny<StripeEventResponseDTO>()));
_donationService.Setup(mocked => mocked.UpdateDonationStatus(1111, 999, e.Created, null)).Returns(1111);
_donationService.Setup(mocked => mocked.UpdateDonationStatus(2222, 999, e.Created, null)).Returns(2222);
_donationService.Setup(mocked => mocked.UpdateDonationStatus(3333, 999, e.Created, null)).Returns(3333);
_donationService.Setup(mocked => mocked.UpdateDonationStatus(7777, 999, e.Created, null)).Returns(7777);
_donationService.Setup(mocked => mocked.CreateDeposit(It.IsAny<DepositDTO>())).Returns(
(DepositDTO o) =>
{
o.Id = 98765;
return (o);
});
_donationService.Setup(mocked => mocked.CreateDonationBatch(It.IsAny<DonationBatchDTO>())).Returns((DonationBatchDTO o) => o);
var result = _fixture.ProcessStripeEvent(e);
Assert.IsNotNull(result);
Assert.IsInstanceOf<TransferPaidResponseDTO>(result);
var tp = (TransferPaidResponseDTO)result;
Assert.AreEqual(6, tp.TotalTransactionCount);
Assert.AreEqual(4, tp.SuccessfulUpdates.Count);
Assert.AreEqual(charges.GetRange(0, 4).Select(charge => charge.Id), tp.SuccessfulUpdates);
Assert.AreEqual(2, tp.FailedUpdates.Count);
Assert.AreEqual("ch444", tp.FailedUpdates[0].Key);
Assert.AreEqual("Not gonna do it, wouldn't be prudent.", tp.FailedUpdates[0].Value);
Assert.AreEqual("ch555", tp.FailedUpdates[1].Key);
Assert.IsNotNull(tp.Batch);
Assert.IsNotNull(tp.Deposit);
Assert.IsNotNull(tp.Exception);
_donationService.Verify(mocked => mocked.CreateDonationBatch(It.Is<DonationBatchDTO>(o =>
o.BatchName.Matches(@"MP\d{12}")
&& o.SetupDateTime == o.FinalizedDateTime
&& o.BatchEntryType == 555
&& o.ItemCount == 4
&& o.BatchTotalAmount == ((111 + 222 + 333 + 777) / Constants.StripeDecimalConversionValue)
&& o.Donations != null
&& o.Donations.Count == 4
&& o.DepositId == 98765
&& o.ProcessorTransferId.Equals("tx9876")
)));
_donationService.Verify(mocked => mocked.CreateDeposit(It.Is<DepositDTO>(o =>
o.DepositName.Matches(@"MP\d{12}")
&& !o.Exported
&& o.AccountNumber.Equals(" ")
&& o.BatchCount == 1
&& o.DepositDateTime != null
&& o.DepositTotalAmount == (1456 / Constants.StripeDecimalConversionValue)
&& o.ProcessorFeeTotal == (13 / Constants.StripeDecimalConversionValue)
&& o.DepositAmount == (1443 / Constants.StripeDecimalConversionValue)
&& o.Notes == null
&& o.ProcessorTransferId.Equals("tx9876")
)));
_paymentService.VerifyAll();
_donationService.VerifyAll();
}
private void AssertList(LispObject list, List<Token> tokens)
{
if (list.IsNil)
{
Assert.IsEmpty(tokens);
}
else
{
var cons = (Cons)list;
var symbol = (Symbol)cons.Car;
Assert.That(symbol.SameName(tokens[0].Name));
AssertList(cons.Cdr, tokens.GetRange(1, tokens.Count - 1));
}
}
public void GetChecklistsShouldReturnNumberOfElementsEqualToSpecifiedPageSize()
{
// Arrange
var repositoryChecklists = new List<ChecklistDto>
{
new ChecklistDto { Title = "A" },
new ChecklistDto { Title = "B" },
new ChecklistDto { Title = "C" },
new ChecklistDto { Title = "D" },
new ChecklistDto { Title = "E" }
};
var fakeRepository = A.Fake<IChecklistRepository>();
A.CallTo(() => fakeRepository.GetChecklists()).Returns(repositoryChecklists.AsQueryable());
var startup = new Startup
{
ControllerConfiguration = new ControllerConfiguration { PageSizeLimit = 100 },
ChecklistRepository = fakeRepository
};
using (WebApp.Start(BaseApiUriString, startup.Configuration))
{
var client = new HttpClient();
// Act
var responseOne = client.GetAsync(new Uri(BaseApiUriString + "/api/checklists?pageNumber=1&pageSize=2")).Result;
var returnedChecklistsOne = JsonConvert.DeserializeObject<List<ChecklistDto>>(responseOne.Content.ReadAsStringAsync().Result);
var responseTwo = client.GetAsync(new Uri(BaseApiUriString + "/api/checklists?pageNumber=2&pageSize=2")).Result;
var returnedChecklistsTwo = JsonConvert.DeserializeObject<List<ChecklistDto>>(responseTwo.Content.ReadAsStringAsync().Result);
var responseThree = client.GetAsync(new Uri(BaseApiUriString + "/api/checklists?pageNumber=3&pageSize=2")).Result;
var returnedChecklistsThree = JsonConvert.DeserializeObject<List<ChecklistDto>>(responseThree.Content.ReadAsStringAsync().Result);
var responseFour = client.GetAsync(new Uri(BaseApiUriString + "/api/checklists?pageNumber=4&pageSize=2")).Result;
var returnedChecklistsFour = JsonConvert.DeserializeObject<List<ChecklistDto>>(responseFour.Content.ReadAsStringAsync().Result);
// Assert
Assert.That(responseOne.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.True(returnedChecklistsOne.SequenceEqual(repositoryChecklists.GetRange(0, 2)));
Assert.That(responseTwo.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.True(returnedChecklistsTwo.SequenceEqual(repositoryChecklists.GetRange(2,2)));
Assert.That(responseThree.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.True(returnedChecklistsThree.SequenceEqual(repositoryChecklists.GetRange(4, 1)));
Assert.That(responseFour.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.IsEmpty(returnedChecklistsFour);
}
}
public void TestGetManyToManyGuidIdentifier()
{
// In this test we will create a N:M relationship between objects of ClassE and ClassF
// Class E - Class F
// --------------------------------------
// 1 - 1
// 2 - 1, 2
// 3 - 1, 2, 3
// 4 - 1, 2, 3, 4
var conn = Utils.CreateConnection();
conn.DropTable<M2MClassE>();
conn.DropTable<M2MClassF>();
conn.DropTable<ClassEClassF>();
conn.CreateTable<M2MClassE>();
conn.CreateTable<M2MClassF>();
conn.CreateTable<ClassEClassF>();
// Use standard SQLite-Net API to create the objects
var objectsF = new List<M2MClassF>
{
new M2MClassF {
Foo = string.Format("1- Foo String {0}", new Random().Next(100))
},
new M2MClassF {
Foo = string.Format("2- Foo String {0}", new Random().Next(100))
},
new M2MClassF {
Foo = string.Format("3- Foo String {0}", new Random().Next(100))
},
new M2MClassF {
Foo = string.Format("4- Foo String {0}", new Random().Next(100))
}
};
conn.InsertAll(objectsF);
var objectsE = new List<M2MClassE>
{
new M2MClassE {
Id = Guid.NewGuid(),
Bar = string.Format("1- Bar String {0}", new Random().Next(100))
},
new M2MClassE {
Id = Guid.NewGuid(),
Bar = string.Format("2- Bar String {0}", new Random().Next(100))
},
new M2MClassE {
Id = Guid.NewGuid(),
Bar = string.Format("3- Bar String {0}", new Random().Next(100))
},
new M2MClassE {
Id = Guid.NewGuid(),
Bar = string.Format("4- Bar String {0}", new Random().Next(100))
}
};
conn.InsertAll(objectsE);
foreach (var objectE in objectsE)
{
var copyE = objectE;
Assert.Null(objectE.FObjects);
// Fetch (yet empty) the relationship
conn.GetChildren(copyE);
Assert.NotNull(copyE.FObjects);
Assert.AreEqual(0, copyE.FObjects.Length);
}
// Create the relationships in the intermediate table
for (var eIndex = 0; eIndex < objectsE.Count; eIndex++)
{
for (var fIndex = 0; fIndex <= eIndex; fIndex++)
{
conn.Insert(new ClassEClassF
{
ClassEId = objectsE[eIndex].Id,
ClassFId = objectsF[fIndex].Id
});
}
}
for (var i = 0; i < objectsE.Count; i++)
{
var objectE = objectsE[i];
// Relationship still empty because hasn't been refreshed
Assert.NotNull(objectE.FObjects);
Assert.AreEqual(0, objectE.FObjects.Length);
// Fetch the relationship
conn.GetChildren(objectE);
var childrenCount = i + 1;
Assert.NotNull(objectE.FObjects);
Assert.AreEqual(childrenCount, objectE.FObjects.Length);
var foos = objectsF.GetRange(0, childrenCount).Select(objectB => objectB.Foo).ToList();
foreach (var objectD in objectE.FObjects)
{
Assert.IsTrue(foos.Contains(objectD.Foo));
}
}
}
public void TestUpdateUnsetManyToManyList()
{
// In this test we will create a N:M relationship between objects of ClassA and ClassB
// Class A - Class B
// --------------------------------------
// 1 - 1
// 2 - 1, 2
// 3 - 1, 2, 3
// 4 - 1, 2, 3, 4
// After that, we will remove objects 1 and 2 from relationships
// Class A - Class B
// --------------------------------------
// 1 - <empty>
// 2 - <empty>
// 3 - 3
// 4 - 3, 4
var conn = Utils.CreateConnection();
conn.DropTable<M2MClassA>();
conn.DropTable<M2MClassB>();
conn.DropTable<ClassAClassB>();
conn.CreateTable<M2MClassA>();
conn.CreateTable<M2MClassB>();
conn.CreateTable<ClassAClassB>();
// Use standard SQLite-Net API to create the objects
var objectsB = new List<M2MClassB>
{
new M2MClassB {
Foo = string.Format("1- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("2- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("3- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("4- Foo String {0}", new Random().Next(100))
}
};
conn.InsertAll(objectsB);
var objectsA = new List<M2MClassA>
{
new M2MClassA {
Bar = string.Format("1- Bar String {0}", new Random().Next(100)),
BObjects = new List<M2MClassB>()
},
new M2MClassA {
Bar = string.Format("2- Bar String {0}", new Random().Next(100)),
BObjects = new List<M2MClassB>()
},
new M2MClassA {
Bar = string.Format("3- Bar String {0}", new Random().Next(100)),
BObjects = new List<M2MClassB>()
},
new M2MClassA {
Bar = string.Format("4- Bar String {0}", new Random().Next(100)),
BObjects = new List<M2MClassB>()
}
};
conn.InsertAll(objectsA);
// Create the relationships
for (var aIndex = 0; aIndex < objectsA.Count; aIndex++)
{
var objectA = objectsA[aIndex];
for (var bIndex = 0; bIndex <= aIndex; bIndex++)
{
var objectB = objectsB[bIndex];
objectA.BObjects.Add(objectB);
}
conn.UpdateWithChildren(objectA);
}
// At these points all the relationships are set
// Class A - Class B
// --------------------------------------
// 1 - 1
// 2 - 1, 2
// 3 - 1, 2, 3
// 4 - 1, 2, 3, 4
// Now we will remove ClassB objects 1 and 2 from the relationships
var objectsBToRemove = objectsB.GetRange(0, 2);
foreach (var objectA in objectsA)
{
objectA.BObjects.RemoveAll(objectsBToRemove.Contains);
conn.UpdateWithChildren(objectA);
}
// This should now be the current status of all relationships
// Class A - Class B
// --------------------------------------
// 1 - <empty>
// 2 - <empty>
// 3 - 3
// 4 - 3, 4
for (var i = 0; i < objectsA.Count; i++)
{
var objectA = objectsA[i];
var storedChildKeyList = (from ClassAClassB ab in conn.Table<ClassAClassB>()
where ab.ClassAId == objectA.Id
select ab.ClassBId).ToList();
var expectedChildIds = objectsB.GetRange(0, i + 1).Where(b => !objectsBToRemove.Contains(b)).Select(objectB => objectB.Id).ToList();
Assert.AreEqual(expectedChildIds.Count, storedChildKeyList.Count, string.Format("Relationship count is not correct for Object with Id {0}", objectA.Id));
foreach (var objectBKey in storedChildKeyList)
{
Assert.IsTrue(expectedChildIds.Contains(objectBKey), "Relationship ID is not correct");
}
}
}
public void TestUpdateSetManyToManyList()
{
// In this test we will create a N:M relationship between objects of ClassA and ClassB
// Class A - Class B
// --------------------------------------
// 1 - 1
// 2 - 1, 2
// 3 - 1, 2, 3
// 4 - 1, 2, 3, 4
var conn = Utils.CreateConnection();
conn.DropTable<M2MClassA>();
conn.DropTable<M2MClassB>();
conn.DropTable<ClassAClassB>();
conn.CreateTable<M2MClassA>();
conn.CreateTable<M2MClassB>();
conn.CreateTable<ClassAClassB>();
// Use standard SQLite-Net API to create the objects
var objectsB = new List<M2MClassB>
{
new M2MClassB {
Foo = string.Format("1- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("2- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("3- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("4- Foo String {0}", new Random().Next(100))
}
};
conn.InsertAll(objectsB);
var objectsA = new List<M2MClassA>
{
new M2MClassA {
Bar = string.Format("1- Bar String {0}", new Random().Next(100)),
BObjects = new List<M2MClassB>()
},
new M2MClassA {
Bar = string.Format("2- Bar String {0}", new Random().Next(100)),
BObjects = new List<M2MClassB>()
},
new M2MClassA {
Bar = string.Format("3- Bar String {0}", new Random().Next(100)),
BObjects = new List<M2MClassB>()
},
new M2MClassA {
Bar = string.Format("4- Bar String {0}", new Random().Next(100)),
BObjects = new List<M2MClassB>()
}
};
conn.InsertAll(objectsA);
// Create the relationships
for (var aIndex = 0; aIndex < objectsA.Count; aIndex++)
{
var objectA = objectsA[aIndex];
for (var bIndex = 0; bIndex <= aIndex; bIndex++)
{
var objectB = objectsB[bIndex];
objectA.BObjects.Add(objectB);
}
conn.UpdateWithChildren(objectA);
}
for (var i = 0; i < objectsA.Count; i++)
{
var objectA = objectsA[i];
var childrenCount = i + 1;
var storedChildKeyList = (from ClassAClassB ab in conn.Table<ClassAClassB>()
where ab.ClassAId == objectA.Id
select ab.ClassBId).ToList();
Assert.AreEqual(childrenCount, storedChildKeyList.Count, "Relationship count is not correct");
var expectedChildIds = objectsB.GetRange(0, childrenCount).Select(objectB => objectB.Id).ToList();
foreach (var objectBKey in storedChildKeyList)
{
Assert.IsTrue(expectedChildIds.Contains(objectBKey), "Relationship ID is not correct");
}
}
}
public void TestGetManyToManyArray()
{
// In this test we will create a N:M relationship between objects of ClassC and ClassD
// Class C - Class D
// --------------------------------------
// 1 - 1
// 2 - 1, 2
// 3 - 1, 2, 3
// 4 - 1, 2, 3, 4
var conn = Utils.CreateConnection();
conn.DropTable<M2MClassC>();
conn.DropTable<M2MClassD>();
conn.DropTable<ClassCClassD>();
conn.CreateTable<M2MClassC>();
conn.CreateTable<M2MClassD>();
conn.CreateTable<ClassCClassD>();
// Use standard SQLite-Net API to create the objects
var objectsD = new List<M2MClassD>
{
new M2MClassD {
Foo = string.Format("1- Foo String {0}", new Random().Next(100))
},
new M2MClassD {
Foo = string.Format("2- Foo String {0}", new Random().Next(100))
},
new M2MClassD {
Foo = string.Format("3- Foo String {0}", new Random().Next(100))
},
new M2MClassD {
Foo = string.Format("4- Foo String {0}", new Random().Next(100))
}
};
conn.InsertAll(objectsD);
var objectsC = new List<M2MClassC>
{
new M2MClassC {
Bar = string.Format("1- Bar String {0}", new Random().Next(100))
},
new M2MClassC {
Bar = string.Format("2- Bar String {0}", new Random().Next(100))
},
new M2MClassC {
Bar = string.Format("3- Bar String {0}", new Random().Next(100))
},
new M2MClassC {
Bar = string.Format("4- Bar String {0}", new Random().Next(100))
}
};
conn.InsertAll(objectsC);
foreach (var objectC in objectsC)
{
var copyC = objectC;
Assert.Null(objectC.DObjects);
// Fetch (yet empty) the relationship
conn.GetChildren(copyC);
Assert.NotNull(copyC.DObjects);
Assert.AreEqual(0, copyC.DObjects.Length);
}
// Create the relationships in the intermediate table
for (var cIndex = 0; cIndex < objectsC.Count; cIndex++)
{
for (var dIndex = 0; dIndex <= cIndex; dIndex++)
{
conn.Insert(new ClassCClassD
{
ClassCId = objectsC[cIndex].Id,
ClassDId = objectsD[dIndex].Id
});
}
}
for (var i = 0; i < objectsC.Count; i++)
{
var objectC = objectsC[i];
// Relationship still empty because hasn't been refreshed
Assert.NotNull(objectC.DObjects);
Assert.AreEqual(0, objectC.DObjects.Length);
// Fetch the relationship
conn.GetChildren(objectC);
var childrenCount = i + 1;
Assert.NotNull(objectC.DObjects);
Assert.AreEqual(childrenCount, objectC.DObjects.Length);
var foos = objectsD.GetRange(0, childrenCount).Select(objectB => objectB.Foo).ToList();
foreach (var objectD in objectC.DObjects)
{
Assert.IsTrue(foos.Contains(objectD.Foo));
}
}
}
public void TestGetManyToManyList()
{
// In this test we will create a N:M relationship between objects of ClassA and ClassB
// Class A - Class B
// --------------------------------------
// 1 - 1
// 2 - 1, 2
// 3 - 1, 2, 3
// 4 - 1, 2, 3, 4
var conn = Utils.CreateConnection();
conn.DropTable<M2MClassA>();
conn.DropTable<M2MClassB>();
conn.DropTable<ClassAClassB>();
conn.CreateTable<M2MClassA>();
conn.CreateTable<M2MClassB>();
conn.CreateTable<ClassAClassB>();
// Use standard SQLite-Net API to create the objects
var objectsB = new List<M2MClassB>
{
new M2MClassB {
Foo = string.Format("1- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("2- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("3- Foo String {0}", new Random().Next(100))
},
new M2MClassB {
Foo = string.Format("4- Foo String {0}", new Random().Next(100))
}
};
conn.InsertAll(objectsB);
var objectsA = new List<M2MClassA>
{
new M2MClassA {
Bar = string.Format("1- Bar String {0}", new Random().Next(100))
},
new M2MClassA {
Bar = string.Format("2- Bar String {0}", new Random().Next(100))
},
new M2MClassA {
Bar = string.Format("3- Bar String {0}", new Random().Next(100))
},
new M2MClassA {
Bar = string.Format("4- Bar String {0}", new Random().Next(100))
}
};
conn.InsertAll(objectsA);
foreach (var objectA in objectsA)
{
var copyA = objectA;
Assert.Null(objectA.BObjects);
// Fetch (yet empty) the relationship
conn.GetChildren(copyA);
Assert.NotNull(copyA.BObjects);
Assert.AreEqual(0, copyA.BObjects.Count);
}
// Create the relationships in the intermediate table
for (var aIndex = 0; aIndex < objectsA.Count; aIndex++)
{
for (var bIndex = 0; bIndex <= aIndex; bIndex++)
{
conn.Insert(new ClassAClassB
{
ClassAId = objectsA[aIndex].Id,
ClassBId = objectsB[bIndex].Id
});
}
}
for (var i = 0; i < objectsA.Count; i++)
{
var objectA = objectsA[i];
// Relationship still empty because hasn't been refreshed
Assert.NotNull(objectA.BObjects);
Assert.AreEqual(0, objectA.BObjects.Count);
// Fetch the relationship
conn.GetChildren(objectA);
var childrenCount = i + 1;
Assert.NotNull(objectA.BObjects);
Assert.AreEqual(childrenCount, objectA.BObjects.Count);
var foos = objectsB.GetRange(0, childrenCount).Select(objectB => objectB.Foo).ToList();
foreach (var objectB in objectA.BObjects)
{
Assert.IsTrue(foos.Contains(objectB.Foo));
}
}
}
public void RemoveRedundant2()
{
const string file = "THE_FILE";
const int line = 666;
const int col = 555;
//test case from MissingMapped
var subject = new AstNull(file, line, col);
var argv = new List<AstExpr>
{
subject,
_createPlaceholder(2),
_createPlaceholder(),
_createPlaceholder(1)
};
var originalArgv = argv.GetRange(0, 2);
_placeholderArgvProcessing(argv);
Assert.AreEqual(originalArgv.Count, argv.Count, "argc not correct");
for (var i = 0; i < originalArgv.Count; i++)
Assert.AreSame(originalArgv[i], argv[i]);
}
