Пример #1
0
/// Tests routing functions in Token.
TEST_F(TokenTest, Routing) {
	// Build 5 nodes. Will test routing between them using explicit route attached to tokens. No need for links or facilities here.
	//std::shared_ptr<Message> dummyContents(new Message("This is a dummy Token contents."));
	std::vector<std::shared_ptr<Node>> nodeVector;
	std::vector<std::shared_ptr<Entity>> explicitRoute;
	for (int i = 0; i < 5; ++i) {
		nodeVector.push_back(std::shared_ptr<Node>(new Node(simulatorGlobals)));
	}
	// Push each node in a certain order to the explicitRoute vector. Let's have the first one as the source, the last one as the destination.
	explicitRoute.push_back(nodeVector.at(0));
	explicitRoute.push_back(nodeVector.at(1));
	explicitRoute.push_back(nodeVector.at(2));
	explicitRoute.push_back(nodeVector.at(3));
	explicitRoute.push_back(nodeVector.at(4));

	// Create one explicit Route.
	//Route route(explicitRoute, true);
	//EXPECT_EQ(explicitRoute, route.getExplicitRoute());

	// Let's test the basic functions for setting and getting explicit route.
	std::shared_ptr<Token> token(new Token(simulatorGlobals, 1, nullptr, nodeVector.at(0), nodeVector.at(4)));
	EXPECT_EQ(token->source, nodeVector.at(0));
	EXPECT_EQ(token->destination, nodeVector.at(4));
	EXPECT_FALSE(token->previous); // That's the way to test for nullptr smart pointers.
	EXPECT_FALSE(token->next);
	// Attach route vector (NOT route object) to token's Route object and set it to record route.
	token->setExplicitRoute(explicitRoute);
	token->setRecordThisRoute();
	EXPECT_EQ(explicitRoute, token->getExplicitRoute());
	// Give the token to the source node and let it forward.
	nodeVector.at(0)->processAndForward(token);
	// Is the first element of recorded route really the source?
	EXPECT_EQ(nodeVector.at(0), token->getRecordedRoute().front());
	// Set the explicit route again, check whether the recorded route was erased.
	token->setExplicitRoute(explicitRoute);
	EXPECT_EQ(0, token->getRecordedRoute().size());
	// Se the record route to false; route should not be recorded.
	token->setDoNotRecordThisRoute();
	// Let's push hops into the recordedRoute.
	token->addHopToRecordedRoute(nodeVector.at(0));
	token->addHopToRecordedRoute(nodeVector.at(1));
	token->addHopToRecordedRoute(nodeVector.at(2));
	token->addHopToRecordedRoute(nodeVector.at(3));
	token->addHopToRecordedRoute(nodeVector.at(4));
	// Recorded route should be empty.
	EXPECT_TRUE(token->getRecordedRoute().empty());
	// Now enable route recording and repeat.
	token->setRecordThisRoute();
	// Let's push hops into the recordedRoute.
	token->addHopToRecordedRoute(nodeVector.at(0));
	token->addHopToRecordedRoute(nodeVector.at(1));
	token->addHopToRecordedRoute(nodeVector.at(2));
	token->addHopToRecordedRoute(nodeVector.at(3));
	token->addHopToRecordedRoute(nodeVector.at(4));
	// That was basically explicitRoute vector. Verify.
	EXPECT_EQ(explicitRoute, token->getRecordedRoute());
	// Now manually furnish nodes to token and allow it to update its previous/next members by calling the forward function.
	// Route is Node 0, 1, 2, 3, 4. Source is 0, destination is 4.
	// Begin with source node. Since the next hop in the list is node 0, previous will be zero, next will be zero. The update function within Token does not treat this.
	token->updateHopsFromExplicitRoute(nodeVector.at(0));
	EXPECT_EQ(nodeVector.at(0), token->previous);
	EXPECT_EQ(nodeVector.at(0), token->next); 
	// Observe that while the token is still "at" current node 0, the next one will be 1 and the previous is 0 after updating forward members. Token is "about" to exit node 0.
	// When the token reaches node 1, the current node is 1, the previous node is 0, and the next node is 1 (before updating forward members).
	// Now "forward" to node 1, the next hop.
	token->updateHopsFromExplicitRoute(nodeVector.at(0));
	EXPECT_EQ(nodeVector.at(0), token->previous);
	EXPECT_EQ(nodeVector.at(1), token->next);
	// Now "forward" to node 2, the next hop.
	token->updateHopsFromExplicitRoute(nodeVector.at(1));
	EXPECT_EQ(nodeVector.at(1), token->previous);
	EXPECT_EQ(nodeVector.at(2), token->next);
	// Now "forward" to node 3, the next hop.
	token->updateHopsFromExplicitRoute(nodeVector.at(2));
	EXPECT_EQ(nodeVector.at(2), token->previous);
	EXPECT_EQ(nodeVector.at(3), token->next);
	// Now "forward" to node 4, the next hop.
	token->updateHopsFromExplicitRoute(nodeVector.at(3));
	EXPECT_EQ(nodeVector.at(3), token->previous);
	EXPECT_EQ(nodeVector.at(4), token->next);
	// Now attempt forwarding past node 4. The token should get stuck at node 4, since the token has no intelligence to consider itself reaching a destination. Attempt this three times.
	token->updateHopsFromExplicitRoute(nodeVector.at(4));
	EXPECT_EQ(nodeVector.at(4), token->previous);
	EXPECT_EQ(nodeVector.at(4), token->next);
	token->updateHopsFromExplicitRoute(nodeVector.at(4));
	EXPECT_EQ(nodeVector.at(4), token->previous);
	EXPECT_EQ(nodeVector.at(4), token->next);
	token->updateHopsFromExplicitRoute(nodeVector.at(4));
	EXPECT_EQ(nodeVector.at(4), token->previous);
	EXPECT_EQ(nodeVector.at(4), token->next);
	
	// Let's attach no route.
	token->setExplicitRoute(std::vector<std::shared_ptr<Entity>>());
	EXPECT_TRUE(token->getExplicitRoute().empty());
	EXPECT_TRUE(token->getRecordedRoute().empty());
	// Now if we attempt to have a node forward the token, it should not work.
	token->updateHopsFromExplicitRoute(nodeVector.at(0));
	EXPECT_EQ(nodeVector.at(0), token->previous);
	EXPECT_FALSE(token->next); // This should be null.
	// Try again. Same outcome.
	token->updateHopsFromExplicitRoute(nodeVector.at(0));
	EXPECT_EQ(nodeVector.at(0), token->previous);
	EXPECT_FALSE(token->next); // This should be null.
	// Have another node forward the token. Only the previous field should be modified.
	token->updateHopsFromExplicitRoute(nodeVector.at(3));
	EXPECT_EQ(nodeVector.at(3), token->previous);
	EXPECT_FALSE(token->next); // This should be null.

	
}
Пример #2
0
TEST_F(ConstFloatTests,
IsPositiveZeroValue) {
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(0.0))->isPositive());
}
Пример #3
0
TEST_F(ConstFloatTests,
IsZeroNegativeValue) {
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(-2.0))->isZero());
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(-8.0))->isZero());
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(-127.5))->isZero());
}
Пример #4
0
TEST(Object, Casts) {
  // Test cast operations
  {
    EXPECT_FALSE(isa<c_Vector>(Object()));
    EXPECT_TRUE(isa_or_null<c_Vector>(Object()));

    auto dummy = makeSmartPtr<c_Vector>();
    Object res(dummy);
    Object empty;
    EXPECT_TRUE(isa<c_Vector>(res));
    EXPECT_TRUE(isa_or_null<c_Vector>(res));

    EXPECT_FALSE(isa<c_Map>(res));
    EXPECT_FALSE(isa_or_null<c_Map>(res));

    // cast tests
    // Bad types and null pointers should throw.
    EXPECT_EQ(cast<c_Vector>(res), dummy);
    EXPECT_EQ(cast<ObjectData>(res), dummy);
    try {
      cast<c_Map>(res);
      EXPECT_FALSE(true);
    } catch(...) {
      EXPECT_TRUE(true);
    }
    try {
      cast<c_Vector>(empty);
      EXPECT_FALSE(true);
    } catch(...) {
      EXPECT_TRUE(true);
    }

    // cast_or_null tests
    // Bad types should throw, null pointers are ok.
    EXPECT_EQ(cast_or_null<ObjectData>(empty), nullptr);
    EXPECT_EQ(cast_or_null<ObjectData>(res), dummy);

    try {
      cast_or_null<c_Map>(res);
      EXPECT_FALSE(true);
    } catch(...) {
      EXPECT_TRUE(true);
    }

    // dyn_cast tests
    // Bad types are ok, null pointers should throw.
    EXPECT_EQ(dyn_cast<c_Vector>(res), dummy);
    EXPECT_EQ(dyn_cast<ObjectData>(res), dummy);
    EXPECT_EQ(dyn_cast<c_Map>(res), nullptr);

    try {
      dyn_cast<c_Vector>(empty);
      EXPECT_FALSE(true);
    } catch(...) {
      EXPECT_TRUE(true);
    }

    // dyn_cast_or_null
    // Bad types and null pointers are ok.  Should never throw.
    EXPECT_EQ(dyn_cast_or_null<c_Map>(res), nullptr);
    EXPECT_EQ(dyn_cast_or_null<ObjectData>(res), dummy);
    EXPECT_EQ(dyn_cast_or_null<ObjectData>(empty), nullptr);
  }
}
Пример #5
0
TEST_F(ConstFloatTests,
IsNegativeOneNegativeNonOneValue) {
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(-1.2))->isNegativeOne());
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(-12.0))->isNegativeOne());
}
Пример #6
0
 void shouldFail(const std::string& message) {
     EXPECT_FALSE(FakeTestReporter::succeeded);
     EXPECT_TRUE(FakeTestReporter::failed);
     EXPECT_EQ(message, *FakeTestReporter::failureMessage);
 }
Пример #7
0
TEST(UUIDTest, NoHyphen) {
  EXPECT_FALSE(isValidUUID("00000000 0000 0000 0000 000000000000"));
}
Пример #8
0
TEST_F(MeshVTKLoaderTest, loadBrokenVtuFile_OpenIssue)
{
    setFilename(DataRepository.getFile("mesh/Armadillo_Tetra_4406_for_test_broken.vtu"));
    EXPECT_FALSE(load());
}
Пример #9
0
TYPED_TEST(BenchmarkTest, TestTimerConstructor) {
  Timer timer;
  EXPECT_TRUE(timer.initted());
  EXPECT_FALSE(timer.running());
  EXPECT_FALSE(timer.has_run_at_least_once());
}
Пример #10
0
TEST_P(FixedAllocatorTest,HasBlock_NULL)
{
    EXPECT_FALSE(fixedAllocator.HasBlock(nullptr));
}
Пример #11
0
TEST_F(MeshVTKLoaderTest, loadBrokenVtkFile_OpenIssue)
{
    setFilename(DataRepository.getFile("mesh/liver_for_test_broken.vtk"));
    EXPECT_FALSE(load());
}
Пример #12
0
TEST(Optional, String) {
  Optional<std::string> maybeString;
  EXPECT_FALSE(maybeString);
  maybeString = "hello";
  EXPECT_TRUE(bool(maybeString));
}
Пример #13
0
TEST(Optional, Comparisons) {
  Optional<int> o_;
  Optional<int> o1(1);
  Optional<int> o2(2);

  EXPECT_TRUE(o_ <= (o_));
  EXPECT_TRUE(o_ == (o_));
  EXPECT_TRUE(o_ >= (o_));

  EXPECT_TRUE(o1 < o2);
  EXPECT_TRUE(o1 <= o2);
  EXPECT_TRUE(o1 <= (o1));
  EXPECT_TRUE(o1 == (o1));
  EXPECT_TRUE(o1 != o2);
  EXPECT_TRUE(o1 >= (o1));
  EXPECT_TRUE(o2 >= o1);
  EXPECT_TRUE(o2 > o1);

  EXPECT_FALSE(o2 < o1);
  EXPECT_FALSE(o2 <= o1);
  EXPECT_FALSE(o2 <= o1);
  EXPECT_FALSE(o2 == o1);
  EXPECT_FALSE(o1 != (o1));
  EXPECT_FALSE(o1 >= o2);
  EXPECT_FALSE(o1 >= o2);
  EXPECT_FALSE(o1 > o2);

  /* folly::Optional explicitly doesn't support comparisons with contained value
  EXPECT_TRUE(1 < o2);
  EXPECT_TRUE(1 <= o2);
  EXPECT_TRUE(1 <= o1);
  EXPECT_TRUE(1 == o1);
  EXPECT_TRUE(2 != o1);
  EXPECT_TRUE(1 >= o1);
  EXPECT_TRUE(2 >= o1);
  EXPECT_TRUE(2 > o1);

  EXPECT_FALSE(o2 < 1);
  EXPECT_FALSE(o2 <= 1);
  EXPECT_FALSE(o2 <= 1);
  EXPECT_FALSE(o2 == 1);
  EXPECT_FALSE(o2 != 2);
  EXPECT_FALSE(o1 >= 2);
  EXPECT_FALSE(o1 >= 2);
  EXPECT_FALSE(o1 > 2);
  */

  // boost::optional does support comparison with contained value, which can
  // lead to confusion when a bool is contained
  boost::optional<int> boi(3);
  EXPECT_TRUE(boi < 5);
  EXPECT_TRUE(boi <= 4);
  EXPECT_TRUE(boi == 3);
  EXPECT_TRUE(boi != 2);
  EXPECT_TRUE(boi >= 1);
  EXPECT_TRUE(boi > 0);
  EXPECT_TRUE(1 <  boi);
  EXPECT_TRUE(2 <= boi);
  EXPECT_TRUE(3 == boi);
  EXPECT_TRUE(4 != boi);
  EXPECT_TRUE(5 >= boi);
  EXPECT_TRUE(6 >  boi);

  boost::optional<bool> bob(false);
  EXPECT_TRUE((bool)bob);
  EXPECT_TRUE(bob == false); // well that was confusing
  EXPECT_FALSE(bob != false);
}
Пример #14
0
IMPLEMENTATION [ia32 || amd64]:

#include "gdt.h"
#include "std_macros.h"
#include "x86desc.h"

PRIVATE inline NEEDS["gdt.h"]
bool
Task::invoke_arch(L4_msg_tag &tag, Utcb *utcb)
{
  switch (utcb->values[0])
    {
    case Ldt_set_x86:
        {
          enum
          {
            Utcb_values_per_ldt_entry
              = Cpu::Ldt_entry_size / sizeof(utcb->values[0]),
          };
          if (EXPECT_FALSE(tag.words() < 3
                           || tag.words() % Utcb_values_per_ldt_entry))
            {
              tag = commit_result(-L4_err::EInval);
              return true;
            }

          unsigned entry_number  = utcb->values[1];
          unsigned size          = (tag.words() - 2) * sizeof(utcb->values[0]);

          // Allocate the memory if not yet done
          if (!_ldt.addr())
            _ldt.alloc();

          if (entry_number * Cpu::Ldt_entry_size + size > Config::PAGE_SIZE)
            {
              WARN("set_ldt: LDT size exceeds one page, not supported.");
              tag = commit_result(-L4_err::EInval);
              return true;
            }

          _ldt.size(size + Cpu::Ldt_entry_size * entry_number);

          Address desc_addr = reinterpret_cast<Address>(&utcb->values[2]);
          Gdt_entry desc;
          Gdt_entry *ldtp
            = reinterpret_cast<Gdt_entry *>(_ldt.addr()) + entry_number;

          while (size >= Cpu::Ldt_entry_size)
            {
              desc = *reinterpret_cast<Gdt_entry const *>(desc_addr);
              if (desc.unsafe())
                {
                  WARN("set_ldt: Bad descriptor.");
                  tag = commit_result(-L4_err::EInval);
                  return true;
                }

              *ldtp      = desc;
              size      -= Cpu::Ldt_entry_size;
              desc_addr += Cpu::Ldt_entry_size;
              ldtp++;
            }

          if (this == current()->space())
            Cpu::cpus.cpu(current_cpu()).enable_ldt(_ldt.addr(), _ldt.size());

          tag = commit_result(0);
        }
      return true;
    }




  return false;
}
Пример #15
0
TEST_F(CueControlTest, OutroCue_SetStartEnd_ClearStartEnd) {
    TrackPointer pTrack = createAndLoadFakeTrack();

    // Set outro start cue
    setCurrentSample(750.0);
    m_pOutroStartSet->slotSet(1);
    m_pOutroStartSet->slotSet(0);
    EXPECT_DOUBLE_EQ(750.0, m_pOutroStartPosition->get());
    EXPECT_TRUE(m_pOutroStartEnabled->toBool());
    EXPECT_DOUBLE_EQ(-1.0, m_pOutroEndPosition->get());
    EXPECT_FALSE(m_pOutroEndEnabled->toBool());

    CuePointer pCue = pTrack->findCueByType(Cue::OUTRO);
    EXPECT_NE(nullptr, pCue);
    if (pCue != nullptr) {
        EXPECT_DOUBLE_EQ(750.0, pCue->getPosition());
        EXPECT_DOUBLE_EQ(0.0, pCue->getLength());
        EXPECT_DOUBLE_EQ(Cue::MANUAL, pCue->getSource());
    }

    // Set outro end cue
    setCurrentSample(1000.0);
    m_pOutroEndSet->slotSet(1);
    m_pOutroEndSet->slotSet(0);
    EXPECT_DOUBLE_EQ(750.0, m_pOutroStartPosition->get());
    EXPECT_TRUE(m_pOutroStartEnabled->toBool());
    EXPECT_DOUBLE_EQ(1000.0, m_pOutroEndPosition->get());
    EXPECT_TRUE(m_pOutroEndEnabled->toBool());

    pCue = pTrack->findCueByType(Cue::OUTRO);
    EXPECT_NE(nullptr, pCue);
    if (pCue != nullptr) {
        EXPECT_DOUBLE_EQ(750.0, pCue->getPosition());
        EXPECT_DOUBLE_EQ(250.0, pCue->getLength());
        EXPECT_DOUBLE_EQ(Cue::MANUAL, pCue->getSource());
    }

    // Clear outro start cue
    m_pOutroStartClear->slotSet(1);
    m_pOutroStartClear->slotSet(0);
    EXPECT_DOUBLE_EQ(-1.0, m_pOutroStartPosition->get());
    EXPECT_FALSE(m_pOutroStartEnabled->toBool());
    EXPECT_DOUBLE_EQ(1000.0, m_pOutroEndPosition->get());
    EXPECT_TRUE(m_pOutroEndEnabled->toBool());

    pCue = pTrack->findCueByType(Cue::OUTRO);
    EXPECT_NE(nullptr, pCue);
    if (pCue != nullptr) {
        EXPECT_DOUBLE_EQ(-1.0, pCue->getPosition());
        EXPECT_DOUBLE_EQ(1000.0, pCue->getLength());
        EXPECT_DOUBLE_EQ(Cue::MANUAL, pCue->getSource());
    }

    // Clear outro end cue
    m_pOutroEndClear->slotSet(1);
    m_pOutroEndClear->slotSet(0);
    EXPECT_DOUBLE_EQ(-1.0, m_pOutroStartPosition->get());
    EXPECT_FALSE(m_pOutroStartEnabled->toBool());
    EXPECT_DOUBLE_EQ(-1.0, m_pOutroEndPosition->get());
    EXPECT_FALSE(m_pOutroEndEnabled->toBool());

    EXPECT_EQ(nullptr, pTrack->findCueByType(Cue::OUTRO));
}
Пример #16
0
TEST(NullIterator, InvalidAfterCreation)
{
	auto it = Iterators::browseNothing<int>();
	EXPECT_FALSE(it->isValid());
}
Пример #17
0
 void shouldSucceed() {
     EXPECT_TRUE(FakeTestReporter::succeeded);
     EXPECT_FALSE(FakeTestReporter::failed);
 }
Пример #18
0
TEST_F(DepotTest, fire) {
    Depot depot(loc, entr, size, name, health);

    EXPECT_FALSE(depot.isBurning());

    EXPECT_DEATH(depot.burningDown(), "");	// ooops, depot is not on fire
    EXPECT_DEATH(depot.stopFire(), "");	// oops, depot is not on fire

    EXPECT_FALSE(depot.isDead());
    EXPECT_FALSE(depot.startSpreadingFire());
    EXPECT_FALSE(depot.startRepair());

    EXPECT_DEATH(depot.repair(), "");	// oops, Depot has still it's original health

    EXPECT_FALSE(depot.isFireTruckAssigned());
    EXPECT_DEATH(depot.assignFireTruck(), "");	// oops, the Depot is not on fire
    EXPECT_DEATH(depot.withdrawFireTruckAssignment(), "");	// oops, there is no firetruck assigned

    // okay, start the fire scenario
    EXPECT_NO_FATAL_FAILURE(depot.setFire());
    EXPECT_TRUE(depot.isBurning());
    EXPECT_NO_FATAL_FAILURE(depot.burningDown());
    EXPECT_EQ(health - reducer, depot.getHealth());
    EXPECT_FALSE(depot.isDead());
    EXPECT_FALSE(depot.startSpreadingFire());	// No, it has lost "only" 2 health points
    EXPECT_FALSE(depot.startRepair());

    EXPECT_DEATH(depot.repair(), "");	// oops, Depot is still on fire

    // let's send a firetruck
    EXPECT_NO_FATAL_FAILURE(depot.assignFireTruck());
    EXPECT_TRUE(depot.isFireTruckAssigned());

    // extinguish fire, repair and sendback firetruck
    EXPECT_DEATH(depot.withdrawFireTruckAssignment(), "");	// oops, Depot is still on fire

    EXPECT_NO_FATAL_FAILURE(depot.stopFire());
    EXPECT_FALSE(depot.isBurning());
    EXPECT_TRUE(depot.startRepair());
    EXPECT_NO_FATAL_FAILURE(depot.repair());
    EXPECT_EQ(health - reducer + 0.5, depot.getHealth());
    EXPECT_NO_FATAL_FAILURE(depot.withdrawFireTruckAssignment());
    EXPECT_FALSE(depot.isFireTruckAssigned());
    EXPECT_FALSE(depot.isDead());

    // fire breaks out again
    EXPECT_NO_FATAL_FAILURE(depot.setFire());
    EXPECT_TRUE(depot.isBurning());
    EXPECT_NO_FATAL_FAILURE(depot.burningDown());
    EXPECT_EQ(health - reducer + 0.5 - reducer, depot.getHealth());
    EXPECT_FALSE(depot.isDead());
    EXPECT_TRUE(depot.startSpreadingFire());

    // let them burning down 'till death
    EXPECT_NO_FATAL_FAILURE(depot.burningDown());
    EXPECT_TRUE(depot.isDead());
    EXPECT_EQ(health - reducer + 0.5 - reducer - reducer, depot.getHealth());

    // now, Depot is not on fire anymore
    EXPECT_FALSE(depot.isBurning());
    EXPECT_FALSE(depot.startRepair());	// you cannot repair a dead Depot
    EXPECT_FALSE(depot.startSpreadingFire());
}
Пример #19
0
TEST_F(SecurityOriginTest, IsPotentiallyTrustworthy)
{
    struct TestCase {
        bool accessGranted;
        const char* url;
    };

    TestCase inputs[] = {
        // Access is granted to webservers running on localhost.
        { true, "http://localhost" },
        { true, "http://LOCALHOST" },
        { true, "http://localhost:100" },
        { true, "http://127.0.0.1" },
        { true, "http://127.0.0.2" },
        { true, "http://127.1.0.2" },
        { true, "http://0177.00.00.01" },
        { true, "http://[::1]" },
        { true, "http://[0:0::1]" },
        { true, "http://[0:0:0:0:0:0:0:1]" },
        { true, "http://[::1]:21" },
        { true, "http://127.0.0.1:8080" },
        { true, "ftp://127.0.0.1" },
        { true, "ftp://127.0.0.1:443" },
        { true, "ws://127.0.0.1" },

        // Access is denied to non-localhost over HTTP
        { false, "http://[1::]" },
        { false, "http://[::2]" },
        { false, "http://[1::1]" },
        { false, "http://[1:2::3]" },
        { false, "http://[::127.0.0.1]" },
        { false, "http://a.127.0.0.1" },
        { false, "http://127.0.0.1.b" },
        { false, "http://localhost.a" },
        { false, "http://a.localhost" },

        // Access is granted to all secure transports.
        { true, "https://foobar.com" },
        { true, "wss://foobar.com" },

        // Access is denied to insecure transports.
        { false, "ftp://foobar.com" },
        { false, "http://foobar.com" },
        { false, "http://foobar.com:443" },
        { false, "ws://foobar.com" },

        // Access is granted to local files
        { true, "file:///home/foobar/index.html" },

        // blob: URLs must look to the inner URL's origin, and apply the same
        // rules as above. Spot check some of them
        { true, "blob:http://localhost:1000/578223a1-8c13-17b3-84d5-eca045ae384a" },
        { true, "blob:https://foopy:99/578223a1-8c13-17b3-84d5-eca045ae384a" },
        { false, "blob:http://baz:99/578223a1-8c13-17b3-84d5-eca045ae384a" },
        { false, "blob:ftp://evil:99/578223a1-8c13-17b3-84d5-eca045ae384a" },

        // filesystem: URLs work the same as blob: URLs, and look to the inner
        // URL for security origin.
        { true, "filesystem:http://localhost:1000/foo" },
        { true, "filesystem:https://foopy:99/foo" },
        { false, "filesystem:http://baz:99/foo" },
        { false, "filesystem:ftp://evil:99/foo" },
    };

    for (size_t i = 0; i < arraysize(inputs); ++i) {
        SCOPED_TRACE(i);
        RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString(inputs[i].url);
        String errorMessage;
        EXPECT_EQ(inputs[i].accessGranted, origin->isPotentiallyTrustworthy(errorMessage));
        EXPECT_EQ(inputs[i].accessGranted, errorMessage.isEmpty());
    }

    // Unique origins are not considered secure.
    RefPtr<SecurityOrigin> uniqueOrigin = SecurityOrigin::createUnique();
    String errorMessage;
    EXPECT_FALSE(uniqueOrigin->isPotentiallyTrustworthy(errorMessage));
    EXPECT_EQ("Only secure origins are allowed (see: https://goo.gl/Y0ZkNV).", errorMessage);
}
 void parseMustFail() {
   _array = &_jsonBuffer.parseArray(_jsonString);
   EXPECT_FALSE(_array->success());
   EXPECT_EQ(0, _array->size());
 }
Пример #21
0
TEST(StringTest, Bool) {
    EXPECT_TRUE(CString(true).ToBool());
    EXPECT_FALSE(CString(false).ToBool());
}
Пример #22
0
TEST(Type, RuntimeType) {
  HPHP::Transl::RuntimeType rt(new StringData());
  Type t = Type::fromRuntimeType(rt);
  EXPECT_TRUE(t.subtypeOf(Type::Str));
  EXPECT_FALSE(t.subtypeOf(Type::Int));

  rt = HPHP::Transl::RuntimeType(HphpArray::GetStaticEmptyArray());
  t = Type::fromRuntimeType(rt);
  EXPECT_TRUE(t.subtypeOf(Type::Arr));
  EXPECT_FALSE(t.subtypeOf(Type::Str));

  rt = HPHP::Transl::RuntimeType(true);
  t = Type::fromRuntimeType(rt);
  EXPECT_TRUE(t.subtypeOf(Type::Bool));
  EXPECT_FALSE(t.subtypeOf(Type::Obj));

  rt = HPHP::Transl::RuntimeType((int64_t) 1);
  t = Type::fromRuntimeType(rt);
  EXPECT_TRUE(t.subtypeOf(Type::Int));
  EXPECT_FALSE(t.subtypeOf(Type::Dbl));

  rt = HPHP::Transl::RuntimeType(DataType::KindOfObject,
                                 DataType::KindOfInvalid);
  rt = rt.setKnownClass(SystemLib::s_TraversableClass);
  t = Type::fromRuntimeType(rt);
  EXPECT_TRUE(t.subtypeOf(Type::Obj));
  EXPECT_FALSE(Type::Obj.subtypeOf(t));
  EXPECT_FALSE(Type::Int.subtypeOf(t));
  HPHP::Transl::RuntimeType rt1 =
    HPHP::Transl::RuntimeType(DataType::KindOfObject,
                              DataType::KindOfInvalid);
  rt1 = rt1.setKnownClass(SystemLib::s_IteratorClass);
  Type t1 = Type::fromRuntimeType(rt1);
  EXPECT_TRUE(t1.subtypeOf(Type::Obj));
  EXPECT_TRUE(t1.subtypeOf(t));
  EXPECT_FALSE(Type::Obj.subtypeOf(t1));
  EXPECT_FALSE(t.subtypeOf(t1));
  EXPECT_FALSE(t.subtypeOf(Type::Str));
  EXPECT_FALSE(Type::Int.subtypeOf(t));
  HPHP::Transl::RuntimeType rtItArr =
    HPHP::Transl::RuntimeType(ArrayIter::IterKind::Array);
  Type tItArr = Type::fromRuntimeType(rtItArr);
  HPHP::Transl::RuntimeType rtItVec =
    HPHP::Transl::RuntimeType(ArrayIter::IterKind::Vector);
  Type tItVec = Type::fromRuntimeType(rtItVec);
  EXPECT_TRUE(tItArr.subtypeOf(Type::Iter));
  EXPECT_TRUE(tItVec.subtypeOf(Type::Iter));
  EXPECT_TRUE(tItVec.strictSubtypeOf(Type::Iter));
  EXPECT_FALSE(tItArr.subtypeOf(tItVec));
  EXPECT_FALSE(tItVec.subtypeOf(tItArr));
  EXPECT_FALSE(tItArr.subtypeOf(Type::Str));
  EXPECT_FALSE(tItArr.subtypeOf(Type::Obj));
  EXPECT_FALSE(tItVec.subtypeOf(Type::Int));
  EXPECT_FALSE(tItVec.subtypeOf(Type::Obj));
  EXPECT_FALSE(tItArr.subtypeOf(t));
  EXPECT_FALSE(tItVec.subtypeOf(t1));
  EXPECT_FALSE(t.subtypeOf(tItArr));
  EXPECT_FALSE(t1.subtypeOf(tItVec));
}
Пример #23
0
TEST_F(ConstFloatTests,
IsNegativePositiveValue) {
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(1.0))->isNegative());
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(5.0))->isNegative());
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(127.5))->isNegative());
}
Пример #24
0
TEST_F(TestFileCache, WriteAndReadBack) {
  // Set up something for FileCache to read in.

  char data_fn[] = "/tmp/hhvm_unit_test-testdata.XXXXXX";
  int data_fd = mkstemp(data_fn);
  ASSERT_GT(data_fd, 0);

  FILE* f = fdopen(data_fd, "w");
  ASSERT_TRUE(f != nullptr);

  fprintf(f, "%s", kTestData);
  fclose(f);

  // Set up a cache and put this data file in it.

  FileCache fc;
  fc.write("_unit_test_one_", data_fn);
  fc.write("_unit_test_two_", false);
  fc.write("/__invalid__/path/with/directories", true);

  string temp_dir;
  ASSERT_TRUE(makeTempDir(&temp_dir));

  string cache_fn(temp_dir);
  cache_fn.append("/cache.dump");

  // Flush to disk.

  fc.save(cache_fn.c_str());

  // Sniff around the on-disk temp file.

  FileCache ondisk;
  EXPECT_EQ(ondisk.getVersion(cache_fn.c_str()), 2);

  // Read back into another cache.

  FileCache fc2;
  fc2.loadMmap(cache_fn.c_str(), 1);

  EXPECT_TRUE(fc2.fileExists("_unit_test_one_"));

  int read_len;
  bool compressed = false;
  const char* read_data = fc2.read("_unit_test_one_", read_len, compressed);

  EXPECT_STREQ(kTestData, read_data);
  EXPECT_EQ(fc2.fileSize("_unit_test_one_", false), strlen(kTestData));

  EXPECT_TRUE(fc2.fileExists("_unit_test_two_"));
  EXPECT_FALSE(fc2.fileExists("_unit_test_three_"));

  EXPECT_TRUE(fc2.dirExists("/__invalid__"));
  EXPECT_TRUE(fc2.dirExists("/__invalid__/path"));
  EXPECT_TRUE(fc2.dirExists("/__invalid__/path/with"));
  EXPECT_TRUE(fc2.fileExists("/__invalid__/path/with/directories"));

  // -1 is a magic value... here it means "it's a PHP file"...
  EXPECT_EQ(fc2.fileSize("unit_test_two_", false), -1);

  // ... and here it means "this thing does not exist".
  EXPECT_EQ(fc2.fileSize("unit_test_three_", false), -1);

  fc2.dump();

  // Clean up the mess.

  ASSERT_EQ(unlink(cache_fn.c_str()), 0);
  ASSERT_EQ(rmdir(temp_dir.c_str()), 0);
  ASSERT_EQ(unlink(data_fn), 0);
}
Пример #25
0
TEST_F(ConstFloatTests,
NegativeOnePositiveNonOneValue) {
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(5.0))->isNegativeOne());
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(12.0))->isNegativeOne());
}
TEST(ResourceRequestTest, CrossThreadResourceRequestData)
{
    ResourceRequest original;
    original.setURL(KURL(ParsedURLString, "http://www.example.com/test.htm"));
    original.setCachePolicy(UseProtocolCachePolicy);
    original.setTimeoutInterval(10);
    original.setFirstPartyForCookies(KURL(ParsedURLString, "http://www.example.com/first_party.htm"));
    original.setRequestorOrigin(SecurityOrigin::create(KURL(ParsedURLString, "http://www.example.com/first_party.htm")));
    original.setHTTPMethod(HTTPNames::GET);
    original.setHTTPHeaderField(AtomicString("Foo"), AtomicString("Bar"));
    original.setHTTPHeaderField(AtomicString("Piyo"), AtomicString("Fuga"));
    original.setPriority(ResourceLoadPriorityLow, 20);

    RefPtr<EncodedFormData> originalBody(EncodedFormData::create("Test Body"));
    original.setHTTPBody(originalBody);
    original.setAllowStoredCredentials(false);
    original.setReportUploadProgress(false);
    original.setHasUserGesture(false);
    original.setDownloadToFile(false);
    original.setSkipServiceWorker(false);
    original.setFetchRequestMode(WebURLRequest::FetchRequestModeCORS);
    original.setFetchCredentialsMode(WebURLRequest::FetchCredentialsModeSameOrigin);
    original.setRequestorID(30);
    original.setRequestorProcessID(40);
    original.setAppCacheHostID(50);
    original.setRequestContext(WebURLRequest::RequestContextAudio);
    original.setFrameType(WebURLRequest::FrameTypeNested);
    original.setHTTPReferrer(Referrer("http://www.example.com/referrer.htm", ReferrerPolicyDefault));

    EXPECT_STREQ("http://www.example.com/test.htm", original.url().string().utf8().data());
    EXPECT_EQ(UseProtocolCachePolicy, original.getCachePolicy());
    EXPECT_EQ(10, original.timeoutInterval());
    EXPECT_STREQ("http://www.example.com/first_party.htm", original.firstPartyForCookies().string().utf8().data());
    EXPECT_STREQ("www.example.com", original.requestorOrigin()->host().utf8().data());
    EXPECT_STREQ("GET", original.httpMethod().utf8().data());
    EXPECT_STREQ("Bar", original.httpHeaderFields().get("Foo").utf8().data());
    EXPECT_STREQ("Fuga", original.httpHeaderFields().get("Piyo").utf8().data());
    EXPECT_EQ(ResourceLoadPriorityLow, original.priority());
    EXPECT_STREQ("Test Body", original.httpBody()->flattenToString().utf8().data());
    EXPECT_FALSE(original.allowStoredCredentials());
    EXPECT_FALSE(original.reportUploadProgress());
    EXPECT_FALSE(original.hasUserGesture());
    EXPECT_FALSE(original.downloadToFile());
    EXPECT_FALSE(original.skipServiceWorker());
    EXPECT_EQ(WebURLRequest::FetchRequestModeCORS, original.fetchRequestMode());
    EXPECT_EQ(WebURLRequest::FetchCredentialsModeSameOrigin, original.fetchCredentialsMode());
    EXPECT_EQ(30, original.requestorID());
    EXPECT_EQ(40, original.requestorProcessID());
    EXPECT_EQ(50, original.appCacheHostID());
    EXPECT_EQ(WebURLRequest::RequestContextAudio, original.requestContext());
    EXPECT_EQ(WebURLRequest::FrameTypeNested, original.frameType());
    EXPECT_STREQ("http://www.example.com/referrer.htm", original.httpReferrer().utf8().data());
    EXPECT_EQ(ReferrerPolicyDefault, original.referrerPolicy());

    OwnPtr<CrossThreadResourceRequestData> data1(original.copyData());
    ResourceRequest copy1(data1.get());

    EXPECT_STREQ("http://www.example.com/test.htm", copy1.url().string().utf8().data());
    EXPECT_EQ(UseProtocolCachePolicy, copy1.getCachePolicy());
    EXPECT_EQ(10, copy1.timeoutInterval());
    EXPECT_STREQ("http://www.example.com/first_party.htm", copy1.firstPartyForCookies().string().utf8().data());
    EXPECT_STREQ("www.example.com", copy1.requestorOrigin()->host().utf8().data());
    EXPECT_STREQ("GET", copy1.httpMethod().utf8().data());
    EXPECT_STREQ("Bar", copy1.httpHeaderFields().get("Foo").utf8().data());
    EXPECT_EQ(ResourceLoadPriorityLow, copy1.priority());
    EXPECT_STREQ("Test Body", copy1.httpBody()->flattenToString().utf8().data());
    EXPECT_FALSE(copy1.allowStoredCredentials());
    EXPECT_FALSE(copy1.reportUploadProgress());
    EXPECT_FALSE(copy1.hasUserGesture());
    EXPECT_FALSE(copy1.downloadToFile());
    EXPECT_FALSE(copy1.skipServiceWorker());
    EXPECT_EQ(WebURLRequest::FetchRequestModeCORS, copy1.fetchRequestMode());
    EXPECT_EQ(WebURLRequest::FetchCredentialsModeSameOrigin, copy1.fetchCredentialsMode());
    EXPECT_EQ(30, copy1.requestorID());
    EXPECT_EQ(40, copy1.requestorProcessID());
    EXPECT_EQ(50, copy1.appCacheHostID());
    EXPECT_EQ(WebURLRequest::RequestContextAudio, copy1.requestContext());
    EXPECT_EQ(WebURLRequest::FrameTypeNested, copy1.frameType());
    EXPECT_STREQ("http://www.example.com/referrer.htm", copy1.httpReferrer().utf8().data());
    EXPECT_EQ(ReferrerPolicyDefault, copy1.referrerPolicy());

    copy1.setAllowStoredCredentials(true);
    copy1.setReportUploadProgress(true);
    copy1.setHasUserGesture(true);
    copy1.setDownloadToFile(true);
    copy1.setSkipServiceWorker(true);
    copy1.setFetchRequestMode(WebURLRequest::FetchRequestModeNoCORS);
    copy1.setFetchCredentialsMode(WebURLRequest::FetchCredentialsModeInclude);

    OwnPtr<CrossThreadResourceRequestData> data2(copy1.copyData());
    ResourceRequest copy2(data2.get());
    EXPECT_TRUE(copy2.allowStoredCredentials());
    EXPECT_TRUE(copy2.reportUploadProgress());
    EXPECT_TRUE(copy2.hasUserGesture());
    EXPECT_TRUE(copy2.downloadToFile());
    EXPECT_TRUE(copy2.skipServiceWorker());
    EXPECT_EQ(WebURLRequest::FetchRequestModeNoCORS, copy1.fetchRequestMode());
    EXPECT_EQ(WebURLRequest::FetchCredentialsModeInclude, copy1.fetchCredentialsMode());
}
Пример #27
0
TEST_F(ConstFloatTests,
IsZeroPositiveValue) {
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(1.0))->isZero());
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(2.18))->isZero());
	EXPECT_FALSE(ConstFloat::create(llvm::APFloat(127.5))->isZero());
}
Пример #28
0
  void AsymmetricKeyFail(Library *lib)
  {
    CppRandom rng;
    QByteArray data(1500, 0);
    rng.GenerateBlock(data);
    QByteArray small_data(10, 0);
    rng.GenerateBlock(small_data);
    QByteArray empty;

    QScopedPointer<AsymmetricKey> key0(lib->CreatePrivateKey());
    QScopedPointer<AsymmetricKey> key1(lib->CreatePrivateKey());
    EXPECT_TRUE(key0->IsValid());
    EXPECT_TRUE(key1->IsValid());

    EXPECT_TRUE(key0->Decrypt(data).isEmpty());
    EXPECT_TRUE(key1->Decrypt(small_data).isEmpty());
    EXPECT_TRUE(key1->Decrypt(empty).isEmpty());

    QByteArray ciphertext = key0->Encrypt(data);
    EXPECT_TRUE(key1->Decrypt(ciphertext).isEmpty());

    ciphertext = key1->Encrypt(empty);
    EXPECT_EQ(key1->Decrypt(ciphertext), empty);

    QByteArray sig = key1->Sign(data);
    EXPECT_TRUE(key1->Verify(data, sig));
    EXPECT_FALSE(key0->Verify(data, sig));
    sig = key1->Sign(small_data);
    EXPECT_TRUE(key1->Verify(small_data, sig));
    EXPECT_FALSE(key0->Verify(small_data, sig));
    sig = key1->Sign(empty);
    EXPECT_TRUE(key1->Verify(empty, sig));
    EXPECT_FALSE(key0->Verify(empty, sig));

    EXPECT_FALSE(key0->Verify(data, empty));
    EXPECT_FALSE(key0->Verify(data, small_data));
    EXPECT_FALSE(key0->Verify(data, data));

    key1.reset(lib->LoadPrivateKeyFromByteArray(data));
    EXPECT_TRUE(!key1->IsValid());
    EXPECT_TRUE(key1->Encrypt(data).isEmpty());
    EXPECT_TRUE(key1->Decrypt(key1->Encrypt(data)).isEmpty());
    EXPECT_FALSE(key1->Verify(data, key1->Sign(data)));
    QScopedPointer<AsymmetricKey> empty_key(key1->GetPublicKey());
    EXPECT_TRUE(empty_key.isNull());

    QString filename = "test_private_key_load";
    EXPECT_FALSE(QFile(filename).exists());
    key1.reset(lib->LoadPrivateKeyFromFile(filename));
    EXPECT_TRUE(!key1->IsValid());
    EXPECT_TRUE(key1->Encrypt(data).isEmpty());
    EXPECT_TRUE(key1->Decrypt(key1->Encrypt(data)).isEmpty());
    EXPECT_FALSE(key1->Verify(data, key1->Sign(data)));
    empty_key.reset(key1->GetPublicKey());
    EXPECT_TRUE(empty_key.isNull());

    key1.reset(lib->LoadPublicKeyFromByteArray(data));
    EXPECT_TRUE(!key1->IsValid());
    EXPECT_TRUE(key1->Encrypt(data).isEmpty());
    EXPECT_TRUE(key1->Decrypt(key1->Encrypt(data)).isEmpty());
    EXPECT_FALSE(key1->Verify(data, key1->Sign(data)));
    empty_key.reset(key1->GetPublicKey());
    EXPECT_TRUE(empty_key.isNull());

    key1.reset(lib->LoadPublicKeyFromFile(filename));
    EXPECT_TRUE(!key1->IsValid());
    EXPECT_TRUE(key1->Encrypt(data).isEmpty());
    EXPECT_TRUE(key1->Decrypt(key1->Encrypt(data)).isEmpty());
    EXPECT_FALSE(key1->Verify(data, key1->Sign(data)));
    empty_key.reset(key1->GetPublicKey());
    EXPECT_TRUE(empty_key.isNull());
  }
Пример #29
0
TEST(StringTests, traits2)
{
    ZString print_non = "\t\e"_s;
    ZString print_mix = "n\t"_s;
    RString print_all = "n "_s;
    EXPECT_FALSE(print_non.has_print());
    EXPECT_TRUE(print_mix.has_print());
    EXPECT_TRUE(print_all.has_print());
    EXPECT_FALSE(print_non.is_print());
    EXPECT_FALSE(print_mix.is_print());
    EXPECT_TRUE(print_all.is_print());
    EXPECT_EQ("__"_s, print_non.to_print());
    EXPECT_EQ("n_"_s, print_mix.to_print());
    EXPECT_EQ("n "_s, print_all.to_print());
    EXPECT_EQ(print_all.begin(), print_all.to_print().begin());

    ZString graph_non = " \e"_s;
    ZString graph_mix = "n "_s;
    RString graph_all = "n."_s;
    EXPECT_FALSE(graph_non.has_graph());
    EXPECT_TRUE(graph_mix.has_graph());
    EXPECT_TRUE(graph_all.has_graph());
    EXPECT_FALSE(graph_non.is_graph());
    EXPECT_FALSE(graph_mix.is_graph());
    EXPECT_TRUE(graph_all.is_graph());

    ZString lower_non = "0A"_s;
    ZString lower_mix = "Oa"_s;
    RString lower_all = "oa"_s;
    EXPECT_FALSE(lower_non.has_lower());
    EXPECT_TRUE(lower_mix.has_lower());
    EXPECT_TRUE(lower_all.has_lower());
    EXPECT_FALSE(lower_non.is_lower());
    EXPECT_FALSE(lower_mix.is_lower());
    EXPECT_TRUE(lower_all.is_lower());
    EXPECT_EQ("0a"_s, lower_non.to_lower());
    EXPECT_EQ("oa"_s, lower_mix.to_lower());
    EXPECT_EQ("oa"_s, lower_all.to_lower());
    EXPECT_EQ(lower_all.begin(), lower_all.to_lower().begin());

    ZString upper_non = "0a"_s;
    ZString upper_mix = "oA"_s;
    RString upper_all = "OA"_s;
    EXPECT_FALSE(upper_non.has_upper());
    EXPECT_TRUE(upper_mix.has_upper());
    EXPECT_TRUE(upper_all.has_upper());
    EXPECT_FALSE(upper_non.is_upper());
    EXPECT_FALSE(upper_mix.is_upper());
    EXPECT_TRUE(upper_all.is_upper());
    EXPECT_EQ("0A"_s, upper_non.to_upper());
    EXPECT_EQ("OA"_s, upper_mix.to_upper());
    EXPECT_EQ("OA"_s, upper_all.to_upper());
    EXPECT_EQ(upper_all.begin(), upper_all.to_upper().begin());

    ZString alpha_non = " 0"_s;
    ZString alpha_mix = "n "_s;
    RString alpha_all = "nA"_s;
    EXPECT_FALSE(alpha_non.has_alpha());
    EXPECT_TRUE(alpha_mix.has_alpha());
    EXPECT_TRUE(alpha_all.has_alpha());
    EXPECT_FALSE(alpha_non.is_alpha());
    EXPECT_FALSE(alpha_mix.is_alpha());
    EXPECT_TRUE(alpha_all.is_alpha());

    ZString digit2_non = "a9"_s;
    ZString digit2_mix = "20"_s;
    RString digit2_all = "01"_s;
    EXPECT_FALSE(digit2_non.has_digit2());
    EXPECT_TRUE(digit2_mix.has_digit2());
    EXPECT_TRUE(digit2_all.has_digit2());
    EXPECT_FALSE(digit2_non.is_digit2());
    EXPECT_FALSE(digit2_mix.is_digit2());
    EXPECT_TRUE(digit2_all.is_digit2());

    ZString digit8_non = "a9"_s;
    ZString digit8_mix = "80"_s;
    RString digit8_all = "37"_s;
    EXPECT_FALSE(digit8_non.has_digit8());
    EXPECT_TRUE(digit8_mix.has_digit8());
    EXPECT_TRUE(digit8_all.has_digit8());
    EXPECT_FALSE(digit8_non.is_digit8());
    EXPECT_FALSE(digit8_mix.is_digit8());
    EXPECT_TRUE(digit8_all.is_digit8());

    ZString digit10_non = "az"_s;
    ZString digit10_mix = "a9"_s;
    RString digit10_all = "42"_s;
    EXPECT_FALSE(digit10_non.has_digit10());
    EXPECT_TRUE(digit10_mix.has_digit10());
    EXPECT_TRUE(digit10_all.has_digit10());
    EXPECT_FALSE(digit10_non.is_digit10());
    EXPECT_FALSE(digit10_mix.is_digit10());
    EXPECT_TRUE(digit10_all.is_digit10());

    ZString digit16_non = "gz"_s;
    ZString digit16_mix = "ao"_s;
    RString digit16_all = "be"_s;
    EXPECT_FALSE(digit16_non.has_digit16());
    EXPECT_TRUE(digit16_mix.has_digit16());
    EXPECT_TRUE(digit16_all.has_digit16());
    EXPECT_FALSE(digit16_non.is_digit16());
    EXPECT_FALSE(digit16_mix.is_digit16());
    EXPECT_TRUE(digit16_all.is_digit16());

    ZString alnum_non = " ."_s;
    ZString alnum_mix = "n "_s;
    RString alnum_all = "n0"_s;
    EXPECT_FALSE(alnum_non.has_alnum());
    EXPECT_TRUE(alnum_mix.has_alnum());
    EXPECT_TRUE(alnum_all.has_alnum());
    EXPECT_FALSE(alnum_non.is_alnum());
    EXPECT_FALSE(alnum_mix.is_alnum());
    EXPECT_TRUE(alnum_all.is_alnum());
}
Пример #30
0
TEST_F(recvbuffTest, Initialization) {
	EXPECT_EQ(RECV_INIT, free_recvbuffs());
	EXPECT_EQ(0, full_recvbuffs());
	EXPECT_FALSE(has_full_recv_buffer());
	EXPECT_TRUE(get_full_recv_buffer() == NULL);
}