/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2015-2020 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief Tests for Cynara::SequenceContainer
*/
-
#include <gtest/gtest.h>
#include <gmock/gmock.h>
using namespace Cynara;
/**
- * @brief Verify if getting and releasing numbers from SequenceContainer works.
- * There are 100 sequence number got and all of them are released in the same order,
- * they were acquired.
+ * @brief Verify that the maximum amount of sequence numbers is returned
+ * and all numbers are unique.
+ * There are UINT16_MAX sequence numbers acquired from SequenceContainer.
+ * Then all acquired numbers are released.
* @test Expected result:
* - getting all sequence number succeeds (returns true)
- * - every got number is the lowest available non-negative integer number
+ * - all acquired numbers are unique
+ * - every acquired number is the lowest available non-negative integer number
* (so sequently 0, 1, 2, 3, ... should be received)
- * - all numbers are successfully (true returned) released
+ * - all acquired numbers are successfully (true returned) released.
*/
-TEST(SequenceContainer, get_linear) {
-
+TEST(SequenceContainer, checkMaxLinearUniquePositive) {
SequenceContainer seqBox;
- constexpr size_t seqMax = 100U;
- ProtocolFrameSequenceNumber seq[seqMax];
+ constexpr unsigned int seqMax = UINT16_MAX + 1;
- for (size_t i = 0; i < seqMax; ++i) {
- bool ret = seqBox.get(seq[i]);
- SCOPED_TRACE(std::string("get : ") + std::to_string(i));
- ASSERT_EQ(true, ret);
- ASSERT_EQ(static_cast<ProtocolFrameSequenceNumber>(i), seq[i]);
+ for (unsigned int i = 0; i < seqMax; i++) {
+ ProtocolFrameSequenceNumber sn;
+ bool ret = seqBox.get(sn);
+ ASSERT_EQ(true, ret) << "Failed to get " << i << "th seq number";
+ ASSERT_EQ(i, sn);
}
- for (size_t i = 0; i < seqMax; ++i) {
- bool ret = seqBox.release(seq[i]);
- SCOPED_TRACE(std::string("release : ") + std::to_string(i));
- ASSERT_EQ(true, ret);
+ for (unsigned int i = 0; i < seqMax; i++) {
+ bool ret = seqBox.release(i);
+ ASSERT_EQ(true, ret) << "Failed to release " << i << "th seq number";
}
}
/**
- * @brief Verify if getting and releasing numbers from SequenceContainer works
+ * @brief Verify that after acquiring the maximum amount of sequence numbers
+ * the next get() call fails.
+ * There are UINT16_MAX sequence numbers acquired from SequenceContainer. Then one more
+ * attempt of acquirement is performed.
+ * @test Expected result:
+ * - getting all UINT16_MAX of sequence numbers succeeds (returns true)
+ * - after all of the UINT16_MAX numbers are acquired, get() fails (returns false).
+ */
+TEST(SequenceContainer, getOverMaximumNegative) {
+ SequenceContainer seqBox;
+ constexpr unsigned int seqMax = UINT16_MAX + 1;
+ ProtocolFrameSequenceNumber seqOverMax = -1;
+
+ for (unsigned int i = 0; i < seqMax; i++) {
+ ProtocolFrameSequenceNumber sn;
+ bool ret = seqBox.get(sn);
+ ASSERT_EQ(true, ret) << "Failed to get " << i << "th seq number";
+ }
+
+ bool ret = seqBox.get(seqOverMax);
+ ASSERT_EQ(false, ret) << "too many values generated";
+}
+
+/**
+ * @brief Verify that getting and releasing numbers from SequenceContainer works
* in case when numbers are reused. There are 100 iterations (j) of zig-zag.
* Every iteration gets 100 sequential numbers (i) and releases them in reverse order.
* @test Expected result:
* - getting all sequence number succeeds (returns true)
- * - every got number is the lowest available non-negative integer number
+ * - every acquired number is the lowest available non-negative integer number
* (so sequently 0, 1, 2, 3, ... should be received in every zig-zag iteration)
* - all numbers are successfully (true returned) released in all zig-zag iterations
*/
-TEST(SequenceContainer, get_zig_zag) {
+TEST(SequenceContainer, getZigZagPositive) {
SequenceContainer seqBox;
constexpr size_t seqMax = 100U;
}
/**
- * @brief Verify if getting and releasing numbers from SequenceContainer works
+ * @brief Verify that getting and releasing numbers from SequenceContainer works
* in case when numbers are got and released insequently.
* There are 100 numbers got at the start of the test case,
* then all odd numbers are released and reacquired.
* @test Expected result:
* - getting all sequence number succeeds (returns true)
- * - every got number is the lowest available non-negative integer number
+ * - every acquired number is the lowest available non-negative integer number
* (so sequently 0, 1, 2, 3, ... should be received during iteration on first loop
* and 1, 3, 5, ... should be received in 3rd loop)
* - all odd numbers are successfully (true returned) released in 2nd loop
*/
-TEST(SequenceContainer, get_odd) {
+TEST(SequenceContainer, getOddPositive) {
SequenceContainer seqBox;
constexpr size_t seqMax = 100U;
}
/**
- * @brief Verify if clearing SequenceContainer works.
+ * @brief Verify that clearing SequenceContainer works.
* There are 100 sequence number got from SequenceContainer. Then a clear() is called.
* After clear() 100 numbers are reacquired and released
* @test Expected result:
* - getting all sequence number succeeds (returns true) both before anf after calling clear()
- * - every got number is the lowest available non-negative integer number
+ * - every acquired number is the lowest available non-negative integer number
* (so sequently 0, 1, 2, 3, ... should be received both before and after clear())
* - all numbers are successfully (true returned) released after they were reacquired.
*/
-TEST(SequenceContainer, clear) {
+TEST(SequenceContainer, clearPositive) {
SequenceContainer seqBox;
constexpr size_t seqMax = 100U;
ASSERT_EQ(true, ret);
}
}
+
+/**
+ * @brief Verify that releasing a sequence number on a full SequenceContainer fails.
+ * There are no sequence numbers acquired from SequenceContainer. Then a release() on
+ * a 'random' number is called.
+ * @test Expected result:
+ * - 'random' number release fails (returns false).
+ */
+TEST(SequenceContainer, releaseUnusedNegative) {
+ SequenceContainer seqBox;
+ ProtocolFrameSequenceNumber sequenceNumberUnused = 42;
+
+ bool ret = seqBox.release(sequenceNumberUnused);
+ ASSERT_EQ(false, ret);
+}
+
+/**
+ * @brief Verify that releasing a non-acquired sequence number fails.
+ * There are 42 sequence numbers acquired from SequenceContainer. Then a release() on
+ * an unacquired number is called. Then all acquired numbers are released.
+ * @test Expected result:
+ * - getting all sequence number succeeds (returns true)
+ * - unacquired number release fails (returns false)
+ * - all acquired numbers are successfully (true returned) released.
+ */
+TEST(SequenceContainer, getReleaseUnusedNegativeReleasePositive) {
+ SequenceContainer seqBox;
+ constexpr unsigned seqMax = 42U;
+ ProtocolFrameSequenceNumber seqUnused = seqMax + 1;
+
+ for (unsigned i = 0; i < seqMax; i++) {
+ ProtocolFrameSequenceNumber sn;
+ bool ret = seqBox.get(sn);
+ SCOPED_TRACE(testing::Message() << "get : " << i);
+ ASSERT_EQ(true, ret);
+ }
+
+ bool ret = seqBox.release(seqUnused);
+ SCOPED_TRACE(testing::Message() << "release : " << seqUnused);
+ ASSERT_EQ(false, ret);
+
+ for (unsigned int i = 0; i < seqMax; i++) {
+ bool ret = seqBox.release(i);
+ SCOPED_TRACE(testing::Message() << "release : " << i);
+ ASSERT_EQ(true, ret);
+ }
+}
+
projects / platform / core / security / cynara.git / commitdiff