public void DoTestSimple2()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 2,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 由于是第二次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
}
public void DoTestSimple3()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 3,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 由于是第一次加入， 不满足 “至少3次”， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 由于是第二次加入， 不满足 “至少3次”， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第三行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today, });
// 由于是第三次加入， 满足 “至少3次”的条件，因此结果列表数据中 3行数据都被加入.
Assert.AreEqual(3, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(3 + i + 1, processer.ResultList.Count);
}
}
public void DoTestSimple2InOneDay()
{
processer = new MultiTimeDataProcess<TestData>()
{
// 至少2次.
AccessAbleCount = 2,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 由于是第二次加入， 但是还是在 同一天的情况， 因此， 结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
// 由于是同一天的情况， 因此， 结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
}
}
public void DoTestMul2InOneDay()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 2,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 由于是第一次加入， 不满足 “至少2次”， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V02", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 加入了 2 行， 2个不同的 Vip， 不满足 “至少2次”，(因为目前每个 vip 各1次) 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第三行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today,
});
// 由于本次加入的数据， 但是还是在 同一天的情况， 因此， 结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
// 但是还是在 同一天的情况， 因此， 结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
}
}
public void DoTestSimple3NotInOneDay()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 3,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-3),
});
// 由于是第一次加入， 不满足 “至少3次”， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today.AddDays(-2),
});
// 由于是第二次加入， 不满足 “至少3次”， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第三行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today.AddDays(-1),
});
// 由于是第三次加入， 满足 “至少3次”的条件，因此结果列表数据中 3行数据都被加入.
Assert.AreEqual(3, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today.AddDays(i),
});
Assert.AreEqual(3 + i + 1, processer.ResultList.Count);
}
}
public void DoTestMul2()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 2,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 由于是第一次加入， 不满足 “至少2次”， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V02", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 加入了 2 行， 2个不同的 Vip， 不满足 “至少2次”，(因为目前每个 vip 各1次) 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第三行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today,
});
// 由于本次加入的数据， 使 V01 满足 “至少2次”的条件，因此结果列表数据中 V01 的 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
}
public void DoTestSimple2InOneDay()
{
processer = new MultiTimeDataProcess <TestData>()
{
// 至少2次.
AccessAbleCount = 2,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 由于是第二次加入， 但是还是在 同一天的情况， 因此， 结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
// 由于是同一天的情况， 因此， 结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
}
}
public void DoTestAddRemove2WithAutoResetInOneDay()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 2,
IsNeedAutoReset = true,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
// 再加入数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S03", SalesAmt = 120, SalesDate = DateTime.Today, });
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 100, SalesDate = DateTime.Today, });
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestAddRemove2NotInOneDay()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 2,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-2), });
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today.AddDays(-1), });
// 由于是第二次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today.AddDays(i), });
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today.AddDays(i), });
Assert.AreEqual(12 - i - 1, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-2), });
// 只剩下一个了.
Assert.AreEqual(1, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-1), });
// 全部删除干净了.
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestAddRemove2WithAutoResetNotInOneDay()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 2,
IsNeedAutoReset = true,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-1), });
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today.AddDays(-2), });
// 由于是第二次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(12 - i - 1, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-1), });
// 因为 启用了 “自动重置”
// 当结果列表中数据不足 2个的时候， 自动将数据从结果列表中 移出.
Assert.AreEqual(0, processer.ResultList.Count);
// 再加入数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S03", SalesAmt = 120, SalesDate = DateTime.Today.AddDays(-3), });
// 本次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-2), });
// 因为 启用了 “自动重置”
// 当结果列表中数据不足 2个的时候， 自动将数据从结果列表中 移出.
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestAddRemove3()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 3,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 由于是第二次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 加入第三行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today,
});
// 由于是第三次加入， 因此结果列表中数据为 1.
// 因为不数据重置， 前面加2次， 减少2次。
// 相当于是 前面加了2次，后面发现前2次 已被加过了，为了重复计算， 从列表中清除了， 但是还是 需要 “算次数”的。
// 因此这一次加入以后， 由于 进入次数等于 3次。 因此认为数据可以加入列表.
Assert.AreEqual(1, processer.ResultList.Count);
// 加入第四行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S04", SalesAmt = 140, SalesDate = DateTime.Today,
});
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(12 - i - 1, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today,
});
// 只剩下1个了.
Assert.AreEqual(1, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S04", SalesAmt = 140, SalesDate = DateTime.Today,
});
// 全部删除干净了.
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestMul2InOneDay()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 2,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 由于是第一次加入， 不满足 “至少2次”， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V02", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 加入了 2 行， 2个不同的 Vip， 不满足 “至少2次”，(因为目前每个 vip 各1次) 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第三行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today, });
// 由于本次加入的数据， 但是还是在 同一天的情况， 因此， 结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
// 但是还是在 同一天的情况， 因此， 结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
}
}
public void DoTestAddRemove3WithAutoReset()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 3,
IsNeedAutoReset = true,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 由于是第二次加入， 不满足 “至少3次”的条件，因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 加入第三行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today, });
// 由于是第三次加入， 因此结果列表中数据为 0.
// 因为数据重置， 前面加2次， 减少2次。
// 相当于是 前面加了2次，后面发现前2次 已被退货了， 需要 取消掉前面的数据。
// 因此这一次加入以后， 进入次数等于 3次。 但是实际有效数据只有1次。
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第四行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S04", SalesAmt = 140, SalesDate = DateTime.Today, });
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第五行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S05", SalesAmt = 150, SalesDate = DateTime.Today, });
Assert.AreEqual(3, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(3 + i + 1, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(13 - i - 1, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S05", SalesAmt = 150, SalesDate = DateTime.Today, });
// 因为 启用了 “自动重置”
// 当结果列表中数据不足 3个的时候， 自动将数据从结果列表中 移出.
Assert.AreEqual(0, processer.ResultList.Count);
// 再加入数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S06", SalesAmt = 160, SalesDate = DateTime.Today, });
// 本次加入， 满足 “至少3次”的条件，因此结果列表数据中 3行数据都被加入.
Assert.AreEqual(3, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S04", SalesAmt = 140, SalesDate = DateTime.Today, });
// 因为 启用了 “自动重置”
// 当结果列表中数据不足 3个的时候， 自动将数据从结果列表中 移出.
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestRemoveNotExistsData2()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 2,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 由于是第二次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
// 尝试删除不存在的数据. 检查会不会出异常.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "X00", SalesAmt = 120, SalesDate = DateTime.Today, });
Assert.AreEqual(12, processer.ResultList.Count);
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(12 - i - 1, processer.ResultList.Count);
}
// 尝试删除不存在的数据. 检查会不会出异常.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "X00", SalesAmt = 120, SalesDate = DateTime.Today, });
Assert.AreEqual(2, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 只剩下一个了.
Assert.AreEqual(1, processer.ResultList.Count);
// 尝试删除不存在的数据. 检查会不会出异常.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "X00", SalesAmt = 120, SalesDate = DateTime.Today, });
Assert.AreEqual(1, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 100, SalesDate = DateTime.Today, });
// 全部删除干净了.
Assert.AreEqual(0, processer.ResultList.Count);
// 尝试删除不存在的数据. 检查会不会出异常.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "X00", SalesAmt = 120, SalesDate = DateTime.Today, });
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestMul2()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 2,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 由于是第一次加入， 不满足 “至少2次”， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V02", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 加入了 2 行， 2个不同的 Vip， 不满足 “至少2次”，(因为目前每个 vip 各1次) 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第三行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today, });
// 由于本次加入的数据， 使 V01 满足 “至少2次”的条件，因此结果列表数据中 V01 的 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
}
public void DoTestAddRemove3()
{
processer = new MultiTimeDataProcess<TestData>()
{
AccessAbleCount = 3,
};
// 加入第一行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 由于是第二次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today, });
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today, });
// 加入第三行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today, });
// 由于是第三次加入， 因此结果列表中数据为 1.
// 因为不数据重置， 前面加2次， 减少2次。
// 相当于是 前面加了2次，后面发现前2次 已被加过了，为了重复计算， 从列表中清除了， 但是还是 需要 “算次数”的。
// 因此这一次加入以后， 由于 进入次数等于 3次。 因此认为数据可以加入列表.
Assert.AreEqual(1, processer.ResultList.Count);
// 加入第四行数据.
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "S04", SalesAmt = 140, SalesDate = DateTime.Today, });
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today, });
Assert.AreEqual(12 - i - 1, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today, });
// 只剩下1个了.
Assert.AreEqual(1, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData() { VipNo = "V01", SalesNo = "S04", SalesAmt = 140, SalesDate = DateTime.Today, });
// 全部删除干净了.
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestAddRemove3WithAutoReset()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 3,
IsNeedAutoReset = true,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 由于是第二次加入， 不满足 “至少3次”的条件，因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 加入第三行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S03", SalesAmt = 130, SalesDate = DateTime.Today,
});
// 由于是第三次加入， 因此结果列表中数据为 0.
// 因为数据重置， 前面加2次， 减少2次。
// 相当于是 前面加了2次，后面发现前2次 已被退货了， 需要 取消掉前面的数据。
// 因此这一次加入以后， 进入次数等于 3次。 但是实际有效数据只有1次。
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第四行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S04", SalesAmt = 140, SalesDate = DateTime.Today,
});
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第五行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S05", SalesAmt = 150, SalesDate = DateTime.Today,
});
Assert.AreEqual(3, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(3 + i + 1, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(13 - i - 1, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S05", SalesAmt = 150, SalesDate = DateTime.Today,
});
// 因为 启用了 “自动重置”
// 当结果列表中数据不足 3个的时候， 自动将数据从结果列表中 移出.
Assert.AreEqual(0, processer.ResultList.Count);
// 再加入数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S06", SalesAmt = 160, SalesDate = DateTime.Today,
});
// 本次加入， 满足 “至少3次”的条件，因此结果列表数据中 3行数据都被加入.
Assert.AreEqual(3, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S04", SalesAmt = 140, SalesDate = DateTime.Today,
});
// 因为 启用了 “自动重置”
// 当结果列表中数据不足 3个的时候， 自动将数据从结果列表中 移出.
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestAddRemove2WithAutoResetInOneDay()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 2,
IsNeedAutoReset = true,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
// 再加入数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S03", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 但是在同一天， 因此还是为 0
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestAddRemove2WithAutoResetNotInOneDay()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 2,
IsNeedAutoReset = true,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-1),
});
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today.AddDays(-2),
});
// 由于是第二次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(12 - i - 1, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-1),
});
// 因为 启用了 “自动重置”
// 当结果列表中数据不足 2个的时候， 自动将数据从结果列表中 移出.
Assert.AreEqual(0, processer.ResultList.Count);
// 再加入数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S03", SalesAmt = 120, SalesDate = DateTime.Today.AddDays(-3),
});
// 本次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-2),
});
// 因为 启用了 “自动重置”
// 当结果列表中数据不足 2个的时候， 自动将数据从结果列表中 移出.
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestAddRemove2NotInOneDay()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 2,
// 不允许同一天.
NotAllowAllInOneDay = true,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-2),
});
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today.AddDays(-1),
});
// 由于是第二次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today.AddDays(i),
});
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today.AddDays(i),
});
Assert.AreEqual(12 - i - 1, processer.ResultList.Count);
}
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-2),
});
// 只剩下一个了.
Assert.AreEqual(1, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 100, SalesDate = DateTime.Today.AddDays(-1),
});
// 全部删除干净了.
Assert.AreEqual(0, processer.ResultList.Count);
}
public void DoTestRemoveNotExistsData2()
{
processer = new MultiTimeDataProcess <TestData>()
{
AccessAbleCount = 2,
};
// 加入第一行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 由于是第一次加入， 因此结果列表中数据为 0.
Assert.AreEqual(0, processer.ResultList.Count);
// 加入第二行数据.
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 120, SalesDate = DateTime.Today,
});
// 由于是第二次加入， 满足 “至少2次”的条件，因此结果列表数据中 2行数据都被加入.
Assert.AreEqual(2, processer.ResultList.Count);
// 后续持续加入
for (int i = 0; i < 10; i++)
{
processer.AddData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(2 + i + 1, processer.ResultList.Count);
}
// 尝试删除不存在的数据. 检查会不会出异常.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "X00", SalesAmt = 120, SalesDate = DateTime.Today,
});
Assert.AreEqual(12, processer.ResultList.Count);
// 开始持续删除.
for (int i = 0; i < 10; i++)
{
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "A0" + i, SalesAmt = 120 + i, SalesDate = DateTime.Today,
});
Assert.AreEqual(12 - i - 1, processer.ResultList.Count);
}
// 尝试删除不存在的数据. 检查会不会出异常.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "X00", SalesAmt = 120, SalesDate = DateTime.Today,
});
Assert.AreEqual(2, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S01", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 只剩下一个了.
Assert.AreEqual(1, processer.ResultList.Count);
// 尝试删除不存在的数据. 检查会不会出异常.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "X00", SalesAmt = 120, SalesDate = DateTime.Today,
});
Assert.AreEqual(1, processer.ResultList.Count);
// 再删除.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "S02", SalesAmt = 100, SalesDate = DateTime.Today,
});
// 全部删除干净了.
Assert.AreEqual(0, processer.ResultList.Count);
// 尝试删除不存在的数据. 检查会不会出异常.
processer.RemoveData(new TestData()
{
VipNo = "V01", SalesNo = "X00", SalesAmt = 120, SalesDate = DateTime.Today,
});
Assert.AreEqual(0, processer.ResultList.Count);
}
