Line data    Source code

       1             : /**
       2             : * @file      EncoderTests.cpp
       3             : * @copyright (c) 2014 by Petr Zemek (s3rvac@gmail.com) and contributors
       4             : * @license   BSD, see the @c LICENSE file for more details
       5             : * @brief     Tests for the Encoder class.
       6             : */
       7             : 
       8             : #include <gtest/gtest.h>
       9             : 
      10             : #include "BDictionary.h"
      11             : #include "BInteger.h"
      12             : #include "BList.h"
      13             : #include "BString.h"
      14             : #include "Encoder.h"
      15             : 
      16             : namespace bencoding {
      17             : namespace tests {
      18             : 
      19             : using namespace testing;
      20             : 
      21          11 : class EncoderTests: public Test {
      22             : protected:
      23          11 :     EncoderTests(): encoder(Encoder::create()) {}
      24             : 
      25             : protected:
      26             :     std::unique_ptr<Encoder> encoder;
      27             : };
      28             : 
      29             : //
      30             : // Dictionary encoding.
      31             : //
      32             : 
      33           5 : TEST_F(EncoderTests,
      34             : EmptyDictionarysIsCorrectlyEncoded) {
      35           2 :     std::shared_ptr<BDictionary> bDictionary(BDictionary::create());
      36             : 
      37           1 :     EXPECT_EQ("de", encoder->encode(bDictionary));
      38           1 : }
      39             : 
      40           5 : TEST_F(EncoderTests,
      41             : DictionarysWithOneItemIsCorrectlyEncoded) {
      42           2 :     std::shared_ptr<BDictionary> bDictionary(BDictionary::create());
      43           1 :     (*bDictionary)[BString::create("test")] = BInteger::create(1);
      44             : 
      45           1 :     EXPECT_EQ("d4:testi1ee", encoder->encode(bDictionary));
      46           1 : }
      47             : 
      48           5 : TEST_F(EncoderTests,
      49             : DictionarysWithTwoItemsIsCorrectlyEncoded) {
      50           2 :     std::shared_ptr<BDictionary> bDictionary(BDictionary::create());
      51           1 :     (*bDictionary)[BString::create("test1")] = BInteger::create(1);
      52           1 :     (*bDictionary)[BString::create("test2")] = BInteger::create(2);
      53             : 
      54           1 :     EXPECT_EQ("d5:test1i1e5:test2i2ee", encoder->encode(bDictionary));
      55           1 : }
      56             : 
      57             : //
      58             : // Integer encoding.
      59             : //
      60             : 
      61           5 : TEST_F(EncoderTests,
      62             : IntegerWithZeroValueIsCorrectlyEncoded) {
      63           2 :     std::shared_ptr<BItem> data(BInteger::create(0));
      64             : 
      65           1 :     EXPECT_EQ("i0e", encoder->encode(data));
      66           1 : }
      67             : 
      68           5 : TEST_F(EncoderTests,
      69             : IntegerWithPositiveValueIsCorrectlyEncoded) {
      70           2 :     std::shared_ptr<BItem> data(BInteger::create(13));
      71             : 
      72           1 :     EXPECT_EQ("i13e", encoder->encode(data));
      73           1 : }
      74             : 
      75           5 : TEST_F(EncoderTests,
      76             : IntegerWithNegativeValueIsCorrectlyEncoded) {
      77           2 :     std::shared_ptr<BItem> data(BInteger::create(-13));
      78             : 
      79           1 :     EXPECT_EQ("i-13e", encoder->encode(data));
      80           1 : }
      81             : 
      82             : //
      83             : // List encoding.
      84             : //
      85             : 
      86           5 : TEST_F(EncoderTests,
      87             : EmptyListIsEncodedCorrectly) {
      88           2 :     std::shared_ptr<BList> bList = BList::create();
      89             : 
      90           1 :     EXPECT_EQ("le", encoder->encode(bList));
      91           1 : }
      92             : 
      93           5 : TEST_F(EncoderTests,
      94             : ListContainingTwoStringsIsEncodedCorrectly) {
      95           2 :     std::shared_ptr<BList> bList = BList::create();
      96           1 :     bList->push_back(BString::create("test"));
      97           1 :     bList->push_back(BString::create("hello"));
      98             : 
      99           1 :     EXPECT_EQ("l4:test5:helloe", encoder->encode(bList));
     100           1 : }
     101             : 
     102             : //
     103             : // String encoding.
     104             : //
     105             : 
     106           5 : TEST_F(EncoderTests,
     107             : EmptyStringIsCorrectlyEncoded) {
     108           2 :     std::shared_ptr<BItem> data(BString::create(""));
     109             : 
     110           1 :     EXPECT_EQ("0:", encoder->encode(data));
     111           1 : }
     112             : 
     113           5 : TEST_F(EncoderTests,
     114             : NonemptyStringIsCorrectlyEncoded) {
     115           2 :     std::shared_ptr<BItem> data(BString::create("test"));
     116             : 
     117           1 :     EXPECT_EQ("4:test", encoder->encode(data));
     118           1 : }
     119             : 
     120             : //
     121             : // Other.
     122             : //
     123             : 
     124           5 : TEST_F(EncoderTests,
     125             : EncodeFunctionWorksAsCreatingEncoderAndCallingEncode) {
     126           2 :     std::shared_ptr<BItem> data(BInteger::create(0));
     127             : 
     128           1 :     EXPECT_EQ("i0e", encode(data));
     129           1 : }
     130             : 
     131             : } // namespace tests
     132           3 : } // namespace bencoding