TEST_F(HTTPDigestAuthenticateTest, RequestStoreDigest_Stale) { std::vector<std::string> test; test.push_back("digest_1"); test.push_back("realm"); test[1] = "realm"; _hc->set_result("/impi/1231231231%40home.domain/av?impu=sip%3A1231231231%40home.domain", test); // set the _impu/_impi _auth_mod->set_members("sip:[email protected]", "GET", "*****@*****.**", 0); // Request the digest. The header will contain the stale parameter std::string www_auth_header; long rc = _auth_mod->request_digest_and_store(www_auth_header, true, _response); EXPECT_THAT(www_auth_header, MatchesRegex("Digest realm=\"home\\.domain\",qop=\"auth\",nonce=\".*\",opaque=\".*\",stale=TRUE")); ASSERT_EQ(rc, 401); }
TEST_F(SessionExpiresHelperTest, ClientSupportsTimerSEModified) { Message msg1; msg1._uac_supports_timer = true; msg1._se = "Session-Expires: 800"; do_request_flow(&msg1); EXPECT_EQ(get_headers(current_txdata()->msg, "Session-Expires"), "Session-Expires: 600"); do_response_flow(); EXPECT_EQ(get_headers(current_txdata()->msg, "Session-Expires"), "Session-Expires: 600;refresher=uac"); EXPECT_THAT(get_headers(current_txdata()->msg, "Require"), MatchesRegex("Require:.*[ ,]timer($|[ ,])")); free_txdata(); }
TEST_F(XPathParserTest, multiple_predicates) { tokens.add({ XPathToken("*"), XPathToken(XPathTokenType::LeftBracket), XPathToken(2.0), XPathToken(XPathTokenType::RightBracket), XPathToken(XPathTokenType::LeftBracket), XPathToken(1.0), XPathToken(XPathTokenType::RightBracket) }); auto expr = parser->parse(); add_child(top_node, "first"); auto second = add_child(top_node, "second"); ASSERT_THAT(evaluate_on(expr, top_node).nodeset(), ElementsAre(second)); }
TEST(ReaderTest, TestReadingMovesPosition) { Reader reader; uint8_t array[] = {0x55, 0xaa, 0x77, 0xee, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}; reader.Initialize(array); ASSERT_THAT(reader.ReadByte(), Eq(0x55)); ASSERT_THAT(reader.ReadWordLE(), Eq(0x77AA)); ASSERT_THAT(reader.ReadDoubleWordLE(), Eq(0x332211EEU)); ASSERT_THAT(reader.ReadArray(3), Eq(gsl::span<const std::uint8_t>(array + 7, 3))); ASSERT_THAT(reader.ReadByte(), Eq(0x77)); ASSERT_THAT(reader.ReadWordBE(), Eq(0x8899)); ASSERT_TRUE(reader.Status()); }
// This test ensures that a framework connecting with a // failed over master gets a registered callback. // Note that this behavior might change in the future and // the scheduler might receive a re-registered callback. TEST_F(FaultToleranceTest, MasterFailover) { Try<PID<Master> > master = StartMaster(); ASSERT_SOME(master); MockScheduler sched; MesosSchedulerDriver driver(&sched, DEFAULT_FRAMEWORK_INFO, master.get()); Future<process::Message> frameworkRegisteredMessage = FUTURE_MESSAGE(Eq(FrameworkRegisteredMessage().GetTypeName()), _, _); EXPECT_CALL(sched, registered(&driver, _, _)); driver.start(); AWAIT_READY(frameworkRegisteredMessage); // Simulate failed over master by restarting the master. Stop(master.get()); master = StartMaster(); ASSERT_SOME(master); EXPECT_CALL(sched, disconnected(&driver)); Future<Nothing> registered; EXPECT_CALL(sched, registered(&driver, _, _)) .WillOnce(FutureSatisfy(®istered)); // Simulate a new master detected message to the scheduler. NewMasterDetectedMessage newMasterDetectedMsg; newMasterDetectedMsg.set_pid(master.get()); process::post(frameworkRegisteredMessage.get().to, newMasterDetectedMsg); // Framework should get a registered callback. AWAIT_READY(registered); driver.stop(); driver.join(); Shutdown(); }
TEST_F(XPathParserTest, filter_expression_and_relative_path) { tokens.add({ XPathToken(XPathTokenType::DollarSign), XPathToken("variable"), XPathToken(XPathTokenType::Slash), XPathToken("child"), }); auto parent = add_child(top_node, "parent"); auto child = add_child(parent, "child"); Nodeset variable_value; variable_value.add(parent); variables.set("variable", variable_value); auto expr = parser->parse(); ASSERT_THAT(evaluate(expr).nodeset(), ElementsAre(child)); }
TEST_F(LibNiceConnectionTest, getCandidate_Passes_Candidate_to_Listener) { GSList* candidate_list = NULL; NiceCandidate* arbitrary_candidate = nice_candidate_new(NICE_CANDIDATE_TYPE_HOST); arbitrary_candidate->username = strdup("an_arbitrary_username"); arbitrary_candidate->password = strdup("an_arbitrary_password"); arbitrary_candidate->stream_id = (guint) 1; arbitrary_candidate->component_id = 1; arbitrary_candidate->priority = 1; arbitrary_candidate->transport = NICE_CANDIDATE_TRANSPORT_UDP; nice_address_set_from_string(&arbitrary_candidate->addr, "192.168.1.1"); nice_address_set_from_string(&arbitrary_candidate->base_addr, "192.168.1.2"); nice_address_set_port(&arbitrary_candidate->addr, 10); nice_address_set_port(&arbitrary_candidate->base_addr, 20); candidate_list = g_slist_prepend(candidate_list, arbitrary_candidate); EXPECT_CALL(*libnice, NiceAgentGetLocalCandidates(_, _, _)).Times(1).WillOnce(Return(candidate_list)); EXPECT_CALL(*nice_listener, onCandidate(_, _)).Times(1); nice_connection->getCandidate(1, 1, "test"); }
// This test checks that when a slave is lost, // its offer(s) is rescinded. TEST_F(FaultToleranceTest, SlaveLost) { Try<PID<Master> > master = StartMaster(); ASSERT_SOME(master); Try<PID<Slave> > slave = StartSlave(); ASSERT_SOME(slave); MockScheduler sched; MesosSchedulerDriver driver(&sched, DEFAULT_FRAMEWORK_INFO, master.get()); EXPECT_CALL(sched, registered(&driver, _, _)); Future<vector<Offer> > offers; EXPECT_CALL(sched, resourceOffers(&driver, _)) .WillOnce(FutureArg<1>(&offers)) .WillRepeatedly(Return()); // Ignore subsequent offers. driver.start(); AWAIT_READY(offers); EXPECT_EQ(1u, offers.get().size()); Future<Nothing> offerRescinded; EXPECT_CALL(sched, offerRescinded(&driver, offers.get()[0].id())) .WillOnce(FutureSatisfy(&offerRescinded)); Future<Nothing> slaveLost; EXPECT_CALL(sched, slaveLost(&driver, offers.get()[0].slave_id())) .WillOnce(FutureSatisfy(&slaveLost)); ShutdownSlaves(); AWAIT_READY(offerRescinded); AWAIT_READY(slaveLost); driver.stop(); driver.join(); Shutdown(); }
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(Process, remote) { ASSERT_TRUE(GTEST_IS_THREADSAFE); RemoteProcess process; volatile bool handlerCalled = false; EXPECT_CALL(process, handler(_, _)) .WillOnce(Assign(&handlerCalled, true)); spawn(process); int s = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); ASSERT_LE(0, s); sockaddr_in addr; memset(&addr, 0, sizeof(addr)); addr.sin_family = PF_INET; addr.sin_port = htons(process.self().port); addr.sin_addr.s_addr = process.self().ip; ASSERT_EQ(0, connect(s, (sockaddr*) &addr, sizeof(addr))); Message message; message.name = "handler"; message.from = UPID(); message.to = process.self(); const std::string& data = MessageEncoder::encode(&message); ASSERT_EQ(data.size(), write(s, data.data(), data.size())); ASSERT_EQ(0, close(s)); while (!handlerCalled); terminate(process); wait(process); }
TEST(EventLogListBuilder, SingleInt) { EventLogListBuilder builder; const uint8_t EXPECTED_LOG[] = { EVENT_TYPE_LIST, 1, // Number of items in the list. EVENT_TYPE_INT, 42, 0, 0, 0, // 4 byte integer value. }; builder.Append(42); std::unique_ptr<uint8_t[]> log; size_t size; builder.Release(&log, &size); EXPECT_EQ(7U, size); uint8_t* log_data = log.get(); EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size), ElementsAreArray(EXPECTED_LOG)); }
TEST_F(HumanPersistenceFacadeTest, subtractHuman_HumanIsPresent_SubtractAll) { ITransactionShrPtr transaction(new TransactionDummy); // Mocks setup: HumanAccessorMock. HumanAccessorMock * mock = new HumanAccessorMock; EXPECT_CALL(*mock, deleteRecord(_, m_id_holder, KEY_WORKER_MINER_NOVICE)); EXPECT_CALL(*mock, getRecord(_, m_id_holder, KEY_WORKER_MINER_NOVICE)) .WillOnce(Return(make_shared<HumanWithVolumeRecord>(m_id_holder, KEY_WORKER_MINER_NOVICE, 5))); // Mocks setup: Wrapping around. IHumanAccessorAutPtr accessor(mock); // Preconditions. HumanPersistenceFacade persistence_facade(m_context, accessor); // Test commands and assertions. ASSERT_TRUE(persistence_facade.subtractHuman(transaction, m_id_holder, KEY_WORKER_MINER_NOVICE, 5)); }
TEST(PvalLoci, NonPvalueLociSkippedDuringInitialization) { istringstream loci_encoding ( "chr1 3000573 3000574 c:0.582447:0.143575 0.2273\n" "chr1 3000725 3000726 c:0.246345:0.06131 -1\n" "chr2 3000900 3000901 c:0.502302:0.11534 0.422782\n" ); vector<PvalLocus> pval_loci; initialize_pval_loci(loci_encoding, pval_loci); ASSERT_THAT(pval_loci.size(), Eq(2)); ASSERT_THAT(pval_loci[0].chrom_ind, Eq(0)); ASSERT_THAT(pval_loci[0].pos, Eq(3000573)); ASSERT_THAT(pval_loci[0].raw_pval, Eq(0.2273)); ASSERT_THAT(pval_loci[1].chrom_ind, Eq(1)); ASSERT_THAT(pval_loci[1].pos, Eq(3000900)); ASSERT_THAT(pval_loci[1].raw_pval, Eq(0.422782)); }
TEST_F(HumanPersistenceFacadeTest, addHuman_HumanIsNotPresent) { ITransactionShrPtr transaction(new TransactionDummy); // Mocks setup: HumanAccessorMock. HumanAccessorMock * mock = new HumanAccessorMock; EXPECT_CALL(*mock, insertRecord(_, m_id_holder, KEY_WORKER_MINER_NOVICE, 5)); EXPECT_CALL(*mock, getRecord(_, m_id_holder, KEY_WORKER_MINER_NOVICE)) .WillOnce(Return(HumanWithVolumeRecordShrPtr())); // Mocks setup: Wrapping around. IHumanAccessorAutPtr accessor(mock); // Preconditions. HumanPersistenceFacade persistence_facade(m_context, accessor); // Test commands and assertions. ASSERT_NO_THROW(persistence_facade.addHuman(transaction, m_id_holder, KEY_WORKER_MINER_NOVICE, 5)); }
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_F(FaultToleranceTest, SlaveReregisterOnZKExpiration) { Try<PID<Master> > master = StartMaster(); ASSERT_SOME(master); Try<PID<Slave> > slave = StartSlave(); ASSERT_SOME(slave); MockScheduler sched; MesosSchedulerDriver driver(&sched, DEFAULT_FRAMEWORK_INFO, master.get()); EXPECT_CALL(sched, registered(&driver, _, _)); Future<Nothing> resourceOffers; EXPECT_CALL(sched, resourceOffers(&driver, _)) .WillOnce(FutureSatisfy(&resourceOffers)) .WillRepeatedly(Return()); // Ignore subsequent offers. driver.start(); AWAIT_READY(resourceOffers); Future<SlaveReregisteredMessage> slaveReregisteredMessage = FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _); // Simulate a spurious newMasterDetected event (e.g., due to ZooKeeper // expiration) at the slave. NewMasterDetectedMessage message; message.set_pid(master.get()); process::post(slave.get(), message); AWAIT_READY(slaveReregisteredMessage); driver.stop(); driver.join(); Shutdown(); }
TEST(Process, order) { ASSERT_TRUE(GTEST_IS_THREADSAFE); Clock::pause(); TimeoutProcess process1; volatile bool timeoutCalled = false; EXPECT_CALL(process1, timeout()) .WillOnce(Assign(&timeoutCalled, true)); spawn(process1); double now = Clock::now(&process1); double seconds = 1.0; Clock::advance(1.0); EXPECT_EQ(now, Clock::now(&process1)); OrderProcess process2; spawn(process2); dispatch(process2, &OrderProcess::order, process1.self()); while (!timeoutCalled); EXPECT_EQ(now + seconds, Clock::now(&process1)); terminate(process1); wait(process1); terminate(process2); wait(process2); Clock::resume(); }
TEST(ProcessTest, Order) { ASSERT_TRUE(GTEST_IS_THREADSAFE); Clock::pause(); TimeoutProcess process1; std::atomic_bool timeoutCalled(false); EXPECT_CALL(process1, timeout()) .WillOnce(Assign(&timeoutCalled, true)); spawn(process1); Time now = Clock::now(&process1); Seconds seconds(1); Clock::advance(Seconds(1)); EXPECT_EQ(now, Clock::now(&process1)); OrderProcess process2; spawn(process2); dispatch(process2, &OrderProcess::order, process1.self()); while (timeoutCalled.load() == false); EXPECT_EQ(now + seconds, Clock::now(&process1)); terminate(process1); wait(process1); terminate(process2); wait(process2); Clock::resume(); }
TEST(HTTPTest, StreamingGetFailure) { Http http; http::Pipe pipe; http::OK ok; ok.type = http::Response::PIPE; ok.reader = pipe.reader(); EXPECT_CALL(*http.process, pipe(_)) .WillOnce(Return(ok)); Future<http::Response> response = http::streaming::get(http.process->self(), "pipe"); // The response should be ready since the headers were sent. AWAIT_READY(response); EXPECT_SOME_EQ("chunked", response.get().headers.get("Transfer-Encoding")); ASSERT_EQ(http::Response::PIPE, response.get().type); ASSERT_SOME(response.get().reader); http::Pipe::Reader reader = response.get().reader.get(); // There is no data to read yet. Future<string> read = reader.read(); EXPECT_TRUE(read.isPending()); // Stream data into the body and read it from the response. http::Pipe::Writer writer = pipe.writer(); EXPECT_TRUE(writer.write("hello")); AWAIT_EQ("hello", read); EXPECT_TRUE(writer.write("goodbye")); AWAIT_EQ("goodbye", reader.read()); // Fail the response. EXPECT_TRUE(writer.fail("oops")); AWAIT_FAILED(reader.read()); }
TEST_F(HumanPersistenceFacadeTest, getHumans_AllHumans_HumansAreNotPresent) { ITransactionShrPtr transaction(new TransactionDummy); // Mocks setup: HumanAccessorMock. HumanAccessorMock * mock = new HumanAccessorMock; EXPECT_CALL(*mock, getRecords(_, m_id_holder)) .WillOnce(Return(HumanWithVolumeRecordMap())); // Mocks setup: Wrapping around. IHumanAccessorAutPtr accessor(mock); // Preconditions. HumanPersistenceFacade persistence_facade(m_context, accessor); // Test commands. HumanWithVolumeMap humans = persistence_facade.getHumans(transaction, m_id_holder); // Test assertions. ASSERT_TRUE(humans.empty()); }
TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBufferNonLatin1UTF8Continuation) { connect(); Checkpoint checkpoint; { InSequence s; EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeBinary, MemEq("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7", 16), 16)); EXPECT_CALL(checkpoint, Call(1)); EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuation, MemEq("\x8b\x90", 2), 2)); } handleClient()->didReceiveFlowControl(handle(), 16); EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()); RefPtr<DOMArrayBuffer> b = DOMArrayBuffer::create("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90", 18); channel()->send(*b, 0, 18); checkpoint.Call(1); handleClient()->didReceiveFlowControl(handle(), 16); EXPECT_EQ(18ul, m_sumOfConsumedBufferedAmount); }
TEST(Process, exited) { ASSERT_TRUE(GTEST_IS_THREADSAFE); UPID pid = spawn(new ProcessBase(), true); ExitedProcess process(pid); volatile bool exitedCalled = false; EXPECT_CALL(process, exited(pid)) .WillOnce(Assign(&exitedCalled, true)); spawn(process); terminate(pid); while (!exitedCalled); terminate(process); wait(process); }
TEST_F(FaultToleranceTest, SlaveReliableRegistration) { Clock::pause(); Try<PID<Master> > master = StartMaster(); ASSERT_SOME(master); // Drop the first slave registered message, allow subsequent messages. Future<SlaveRegisteredMessage> slaveRegisteredMessage = DROP_PROTOBUF(SlaveRegisteredMessage(), _, _); Try<PID<Slave> > slave = StartSlave(); ASSERT_SOME(slave); MockScheduler sched; MesosSchedulerDriver driver(&sched, DEFAULT_FRAMEWORK_INFO, master.get()); EXPECT_CALL(sched, registered(&driver, _, _)); Future<Nothing> resourceOffers; EXPECT_CALL(sched, resourceOffers(&driver, _)) .WillOnce(FutureSatisfy(&resourceOffers)) .WillRepeatedly(Return()); // Ignore subsequent offers. driver.start(); AWAIT_READY(slaveRegisteredMessage); Clock::advance(Seconds(1)); // TODO(benh): Pull out constant from Slave. AWAIT_READY(resourceOffers); driver.stop(); driver.join(); Shutdown(); Clock::resume(); }
TEST(EventLogListBuilder, SingleString) { EventLogListBuilder builder; const uint8_t EXPECTED_LOG[] = { EVENT_TYPE_LIST, 1, // Number of items in the list. EVENT_TYPE_STRING, 5, 0, 0, 0, // 4 byte length of the string. 'D', 'r', 'o', 'i', 'd', }; builder.Append("Droid"); std::unique_ptr<uint8_t[]> log; size_t size; builder.Release(&log, &size); EXPECT_EQ(12U, size); uint8_t* log_data = log.get(); EXPECT_THAT(std::vector<uint8_t>(log_data, log_data + size), ElementsAreArray(EXPECTED_LOG)); }
TEST(ProcessTest, InjectExited) { ASSERT_TRUE(GTEST_IS_THREADSAFE); UPID pid = spawn(new ProcessBase(), true); ExitedProcess process(pid); std::atomic_bool exitedCalled(false); EXPECT_CALL(process, exited(pid)) .WillOnce(Assign(&exitedCalled, true)); spawn(process); inject::exited(pid, process.self()); while (exitedCalled.load() == false); terminate(process); wait(process); }
TEST_F(ResourceOffersTest, ResourceOfferWithMultipleSlaves) { Try<PID<Master> > master = StartMaster(); ASSERT_SOME(master); // Start 10 slaves. for (int i = 0; i < 10; i++) { slave::Flags flags = CreateSlaveFlags(); flags.resources = Option<std::string>("cpus:2;mem:1024"); Try<PID<Slave> > slave = StartSlave(flags); ASSERT_SOME(slave); } MockScheduler sched; MesosSchedulerDriver driver(&sched, DEFAULT_FRAMEWORK_INFO, master.get()); EXPECT_CALL(sched, registered(&driver, _, _)) .Times(1); Future<vector<Offer> > offers; EXPECT_CALL(sched, resourceOffers(&driver, _)) .WillOnce(FutureArg<1>(&offers)) .WillRepeatedly(Return()); // All 10 slaves might not be in first offer. driver.start(); AWAIT_READY(offers); EXPECT_NE(0u, offers.get().size()); EXPECT_GE(10u, offers.get().size()); Resources resources(offers.get()[0].resources()); EXPECT_EQ(2, resources.get("cpus", Value::Scalar()).value()); EXPECT_EQ(1024, resources.get("mem", Value::Scalar()).value()); driver.stop(); driver.join(); Shutdown(); }
TEST(PvalLoci, PvalueLociUpdated) { string input = "chr1 3000573 3000574 c:0.582447:0.143575 0.2273\n" "chr1 3000725 3000726 c:0.246345:0.06131 -1\n" "chr2 3000900 3000901 c:0.502302:0.11534 0.422782\n"; istringstream loci_encoding(input); vector<PvalLocus> pval_loci; initialize_pval_loci(loci_encoding, pval_loci); istringstream second_loci_encoding(input); ostringstream output_loci_encoding; update_pval_loci(second_loci_encoding, pval_loci, output_loci_encoding); string output = "chr1\t3000573\t3000574\tc:0.582447:0.143575:0.2273:0\t0\n" "chr1\t3000725\t3000726\tc:0.246345:0.06131\t-1\n" "chr2\t3000900\t3000901\tc:0.502302:0.11534:0.422782:0\t0\n"; ASSERT_THAT(output_loci_encoding.str(), Eq(output)); }
// Test that a smooth scroll offset animation is aborted when followed by a // non-smooth scroll offset animation. TEST(ScrollAnimatorTest, AnimatedScrollAborted) { OwnPtrWillBeRawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(true); OwnPtrWillBeRawPtr<ScrollAnimator> scrollAnimator = adoptPtrWillBeNoop( new ScrollAnimator(scrollableArea.get(), getMockedTime)); EXPECT_CALL(*scrollableArea, minimumScrollPosition()).Times(AtLeast(1)) .WillRepeatedly(Return(IntPoint())); EXPECT_CALL(*scrollableArea, maximumScrollPosition()).Times(AtLeast(1)) .WillRepeatedly(Return(IntPoint(1000, 1000))); EXPECT_CALL(*scrollableArea, setScrollOffset(_, _)).Times(3); EXPECT_CALL(*scrollableArea, registerForAnimation()).Times(2); EXPECT_CALL(*scrollableArea, scheduleAnimation()).Times(AtLeast(1)) .WillRepeatedly(Return(true)); EXPECT_FALSE(scrollAnimator->hasAnimationThatRequiresService()); // Smooth scroll. ScrollResultOneDimensional result = scrollAnimator->userScroll( HorizontalScrollbar, ScrollByLine, 100, 1); EXPECT_TRUE(scrollAnimator->hasAnimationThatRequiresService()); EXPECT_TRUE(result.didScroll); EXPECT_FLOAT_EQ(0.0, result.unusedScrollDelta); EXPECT_TRUE(scrollAnimator->hasRunningAnimation()); gMockedTime += 0.05; scrollAnimator->updateCompositorAnimations(); scrollAnimator->tickAnimation(getMockedTime()); EXPECT_NE(100, scrollAnimator->currentPosition().x()); EXPECT_NE(0, scrollAnimator->currentPosition().x()); EXPECT_EQ(0, scrollAnimator->currentPosition().y()); float x = scrollAnimator->currentPosition().x(); // Instant scroll. result = scrollAnimator->userScroll( HorizontalScrollbar, ScrollByPrecisePixel, 100, 1); EXPECT_TRUE(result.didScroll); EXPECT_FALSE(scrollAnimator->hasRunningAnimation()); EXPECT_EQ(x + 100, scrollAnimator->currentPosition().x()); EXPECT_EQ(0, scrollAnimator->currentPosition().y()); reset(*scrollAnimator); }
TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBufferPartial) { connect(); { InSequence s; EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("foo", 3), 3)); EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("bar", 3), 3)); EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("baz", 3), 3)); EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("a", 1), 1)); } handleClient()->didReceiveFlowControl(handle(), 16); EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()); RefPtr<DOMArrayBuffer> foobarBuffer = DOMArrayBuffer::create("foobar", 6); RefPtr<DOMArrayBuffer> qbazuxBuffer = DOMArrayBuffer::create("qbazux", 6); channel()->send(*foobarBuffer, 0, 3); channel()->send(*foobarBuffer, 3, 3); channel()->send(*qbazuxBuffer, 1, 3); channel()->send(*qbazuxBuffer, 2, 1); EXPECT_EQ(10ul, m_sumOfConsumedBufferedAmount); }