TEST_F(IRCSockTest, OnTextMessage) {
CMessage msg(":nick PRIVMSG #chan :hello");
m_pTestModule->eAction = CModule::HALT;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnChanTextMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(m_pTestChan));
EXPECT_THAT(m_pTestClient->vsLines, IsEmpty()); // halt
m_pTestModule->eAction = CModule::CONTINUE;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
m_pTestClient->Reset();
m_pTestModule->Reset();
msg.Parse(":nick PRIVMSG me :hello");
m_pTestModule->eAction = CModule::HALT;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnPrivTextMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(nullptr));
EXPECT_THAT(m_pTestClient->vsLines, IsEmpty()); // halt
m_pTestModule->eAction = CModule::CONTINUE;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
}
TEST_F(CandidateCacheFixture, NeedsFillingForward) {
Loc l1 = Loc(1,1);
Loc l2 = Loc(2,2);
Loc l3 = Loc(3,3);
Loc l4 = Loc(4,4);
Loc l5 = Loc(5,5);
Loc l6 = Loc(6,6);
Loc *locs0 = cc.getBuffer(0);
BD(cout << "Before: " << locs0[0]._value << endl);
locs0[0] = l1;
locs0[1] = l2;
locs0[2] = l3;
BD(cout << "After: " << locs0[0]._value << endl);
cc.setDepthMoves(0,3);
Loc *locs1 = cc.getBuffer(1);
locs1[0] = l4;
locs1[1] = l5;
locs1[2] = l6;
cc.setDepthMoves(1,3);
vector<Loc> res_locs1 = getMoves(1);
ASSERT_THAT(res_locs1, ElementsAre(l4,l5,l6));
vector<Loc> res_locs0 = getMoves(0);
ASSERT_THAT(res_locs0, ElementsAre(l1,l2,l3));
vector<Loc> res_locs0_again = getMoves(0);
ASSERT_THAT(res_locs0_again, ElementsAre());
}
TEST_F(IRCSockTest, OnJoinMessage) {
CMessage msg(":somebody JOIN #chan");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnJoinMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(m_pTestChan));
}
TEST_F(IRCSockTest, OnPartMessage) {
CMessage msg(":nick PART #chan :reason");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnPartMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(m_pTestChan));
}
TEST(CoverageTest, load)
{
Coverage c;
std::stringstream coverage_str("bar\t6\n1\n1\n1\n0\n0\n0\nfoo\t5\n0\n0\n1\n1\n0\n");
c.load(coverage_str);
EXPECT_THAT(c.coverages.find("bar")->second, ElementsAre(1, 1, 1, 0, 0, 0));
EXPECT_THAT(c.coverages.find("foo")->second, ElementsAre(0, 0, 1, 1, 0));
}
TEST_F(IRCSockTest, OnQuitMessage) {
CMessage msg(":nobody QUIT :bye");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnQuitMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(nullptr));
msg.Parse(":nick QUIT :bye");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
}
TEST(CoverageTest, Coverage_setMinReferenceLength)
{
Coverage c;
EXPECT_EQ(0, c.coverages.size());
c.setMinReferenceLength("foo", 10);
EXPECT_EQ(1, c.coverages.size());
EXPECT_THAT(c.coverages.find("foo")->second,
ElementsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
c.setMinReferenceLength("foo", 5);
EXPECT_THAT(c.coverages.find("foo")->second,
ElementsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
}
TEST_F(IRCSockTest, OnNickMessage) {
CMessage msg(":nobody NICK nick");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnNickMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(nullptr));
EXPECT_THAT(m_pTestClient->vsLines, IsEmpty());
msg.Parse(":nick NICK somebody");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
}
TEST(CoverageTest, Coverage_add_alignment)
{
Alignment a;
a.RefName = "foo";
a.position(3);
CigarOp op;
a.CigarData.clear();
op.Type = 'M';
op.Length = 2;
a.CigarData.push_back(op);
op.Type = 'N';
op.Length = 3;
a.CigarData.push_back(op);
op.Type = 'M';
op.Length = 2;
a.CigarData.push_back(op);
Coverage c;
c.add(a);
EXPECT_THAT(c.coverages.find("foo")->second, ElementsAre(0, 0, 1, 1, 0, 0, 0, 1, 1));
}
TEST(ReaderTest, readAllAndLinkChildren)
{
typedef vector<Feature>::iterator Feature_iter;
std::stringstream data;
data << "Chr\t.\tgene\t20\t30\t0\t+\t0\tID=one" << std::endl;
data << "Chr\t.\tgene\t20\t30\t0\t+\t0\tID=two;Parent=one;" << std::endl;
data << "Chr\t.\tgene\t20\t30\t0\t+\t0\tID=three;Parent=one;" << std::endl;
vector<Feature> ret;
Reader::readAllAndLinkChildren(data, ret);
EXPECT_EQ(3, ret.size());
Feature d = ret.at(0);
vector<string> IDs;
for (Feature_iter it = d.children.begin(); it != d.children.end(); ++it)
{
string ID = "";
it->attributes.get("ID", ID);
IDs.push_back(ID);
}
EXPECT_THAT(IDs, WhenSorted(ElementsAre("three", "two")));
EXPECT_EQ(0, ret.at(1).children.size());
EXPECT_EQ(0, ret.at(2).children.size());
}
TEST_F(IRCSockTest, OnTopicMessage) {
CMessage msg(":nick TOPIC #chan :topic");
m_pTestModule->eAction = CModule::HALT;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnTopicMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(m_pTestChan));
EXPECT_THAT(m_pTestClient->vsLines, IsEmpty()); // halt
m_pTestModule->eAction = CModule::CONTINUE;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
}
TEST_F(IRCSockTest, OnNumericMessage) {
CMessage msg(":irc.server.com 372 nick :motd");
m_pTestModule->eAction = CModule::HALT;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnNumericMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(nullptr));
EXPECT_THAT(m_pTestClient->vsLines, IsEmpty()); // halt
m_pTestModule->eAction = CModule::CONTINUE;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
}
TEST(AttributesTest, funky_attribute_def)
{
vector<string> v;
Attributes a;
a.addFromGFF("foo=1;foo=2");
EXPECT_TRUE(a.all("foo", v));
EXPECT_THAT(v, ElementsAre("1", "2"));
}
TEST_F(AntennaMiniportTest, TestAntennaTemperatureFailure)
{
EXPECT_CALL(i2c, WriteRead(ANTENNA_PRIMARY_CHANNEL, ElementsAre(QueryTemperature), _)).WillOnce(Return(I2CResult::Nack));
uint16_t response;
const auto status = miniport.GetTemperature(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL, &response);
ASSERT_THAT(status, Ne(OSResult::Success));
ASSERT_THAT(response, Eq(0u));
}
TEST_F(AntennaMiniportTest, TestAntennaActivationTimeFailure)
{
EXPECT_CALL(i2c, WriteRead(ANTENNA_PRIMARY_CHANNEL, ElementsAre(QueryActivationTime2), _)).WillOnce(Return(I2CResult::Nack));
TimeSpan response;
const auto status = miniport.GetAntennaActivationTime(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL, ANTENNA2_ID, &response);
ASSERT_THAT(status, Ne(OSResult::Success));
ASSERT_THAT(response, Eq(TimeSpanFromMilliseconds(0u)));
}
TEST(MemIndexTest, MemIndexDeduplicate) {
std::vector<Symbol> Symbols = {symbol("1"), symbol("2"), symbol("3"),
symbol("2") /* duplicate */};
FuzzyFindRequest Req;
Req.Query = "2";
MemIndex I(Symbols, RefSlab());
EXPECT_THAT(match(I, Req), ElementsAre("2"));
}
TEST_F(IRCSockTest, OnModeMessage) {
CMessage msg(":nick MODE #chan +k key");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks,
IsEmpty()); // no OnModeMessage() hook (yet?)
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
}
TEST_F(IRCSockTest, OnInviteMessage) {
CMessage msg(":nick INVITE me #znc");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks,
IsEmpty()); // no OnInviteMessage() hook (yet?)
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
}
TEST_F(IRCSockTest, OnWallopsMessage) {
CMessage msg(":blub!dummy@rox-8DBEFE92 WALLOPS :this is a test");
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks,
IsEmpty()); // no OnWallopsMessage() hook (yet?)
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
}
TEST_F(AntennaMiniportTest, TestAntennaActivationCountFailure)
{
EXPECT_CALL(i2c, WriteRead(ANTENNA_BACKUP_CHANNEL, ElementsAre(QueryActivationCount2), _)).WillOnce(Return(I2CResult::Nack));
uint16_t response;
const auto status = miniport.GetAntennaActivationCount(&miniport, &i2c, ANTENNA_BACKUP_CHANNEL, ANTENNA2_ID, &response);
ASSERT_THAT(status, Ne(OSResult::Success));
ASSERT_THAT(response, Eq(0u));
}
TEST_F(IRCSockTest, OnSendToIRCMessage) {
CMessage msg(":nick PRIVMSG #chan :hello");
m_pTestModule->eAction = CModule::HALT;
m_pTestModule->bSendHooks = true;
m_pTestSock->PutIRC(msg.ToString());
EXPECT_THAT(m_pTestModule->vsHooks, ElementsAre("OnSendToIRCMessage"));
EXPECT_THAT(m_pTestModule->vsMessages, ElementsAre(msg.ToString()));
EXPECT_THAT(m_pTestModule->vNetworks, ElementsAre(m_pTestNetwork));
EXPECT_THAT(m_pTestModule->vChannels, ElementsAre(nullptr));
EXPECT_THAT(m_pTestClient->vsLines, IsEmpty()); // halt
m_pTestModule->eAction = CModule::CONTINUE;
m_pTestSock->ReadLine(msg.ToString());
EXPECT_THAT(m_pTestClient->vsLines, ElementsAre(msg.ToString()));
m_pTestModule->bSendHooks = false;
}
TEST_F(XPathParserTest, parses_child_with_same_name_as_an_axis)
{
tokens.add(XPathToken("self"));
auto expr = parser->parse();
auto self = add_child(top_node, "self");
ASSERT_THAT(evaluate_on(expr, top_node).nodeset(), ElementsAre(self));
}
TEST_F(XPathTokenDeabbreviatorTest, converts_at_sign_to_attribute_axis)
{
tokenizer.add(XPathTokenType::AtSign);
XPathTokenDeabbreviator deabbrv(tokenizer);
ASSERT_THAT(all_tokens(deabbrv), ElementsAre(XPathToken("attribute"),
XPathToken(XPathTokenType::DoubleColon)));
}
TEST_F(XPathAcceptanceTest, self_axis_selects_self)
{
Element *one = doc.new_element("one");
XPath xpath = compile("self::one");
Nodeset selected_nodes = one->select_nodes(xpath);
ASSERT_THAT(selected_nodes, ElementsAre(one));
}
TEST(AttributesTest, all)
{
vector<string> v;
Attributes a;
a.addFromGFF("foo=bar%2Cbaz,bat");
EXPECT_TRUE(a.all("foo", v));
EXPECT_FALSE(a.all("non-existent", v));
EXPECT_THAT(v, ElementsAre("bar,baz", "bat"));
}
TEST_F(XPathAcceptanceTest, dot_abbreviation_selects_self)
{
Element *one = doc.new_element("one");
XPath xpath = compile(".");
Nodeset selected_nodes = one->select_nodes(xpath);
ASSERT_THAT(selected_nodes, ElementsAre(one));
}
TEST_F(XPathAcceptanceTest, name_selects_child_element)
{
Element *one = doc.new_element("one");
Element *two = add_child(one, "two");
XPath xpath = compile("two");
Nodeset selected_nodes = one->select_nodes(xpath);
ASSERT_THAT(selected_nodes, ElementsAre(two));
}
TEST_F(XPathAcceptanceTest, at_sign_abbreviation_selects_attributes)
{
Element *element = doc.new_element("element");
Attribute *attribute = set_attribute(element, "name", "value");
XPath xpath = compile("@name");
Nodeset selected_nodes = element->select_nodes(xpath);
ASSERT_THAT(selected_nodes, ElementsAre(attribute));
}
TEST_F(XPathAcceptanceTest, text_node_node_test_selects_text_nodes)
{
Element *parent = doc.new_element("element");
TextNode *text = add_text_node(parent, "some text");
XPath xpath = compile("text()");
Nodeset selected_nodes = parent->select_nodes(xpath);
ASSERT_THAT(selected_nodes, ElementsAre(text));
}
TEST_F(XPathAcceptanceTest, selector_with_same_name_as_an_axis_selects_element)
{
Element *one = doc.new_element("one");
Element *self = add_child(one, "self");
XPath xpath = compile("self");
Nodeset selected_nodes = one->select_nodes(xpath);
ASSERT_THAT(selected_nodes, ElementsAre(self));
}
