net/cert/pem_tokenizer_unittest.cc

   1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/cert/pem_tokenizer.h"
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8
   9 namespace net {
  10
  11 TEST(PEMTokenizerTest, BasicParsing) {
  12   const char data[] =
  13       "-----BEGIN EXPECTED-BLOCK-----\n"
  14       "TWF0Y2hlc0FjY2VwdGVkQmxvY2tUeXBl\n"
  15       "-----END EXPECTED-BLOCK-----\n";
  16   base::StringPiece string_piece(data);
  17   std::vector<std::string> accepted_types;
  18   accepted_types.push_back("EXPECTED-BLOCK");
  19
  20   PEMTokenizer tokenizer(string_piece, accepted_types);
  21   EXPECT_TRUE(tokenizer.GetNext());
  22
  23   EXPECT_EQ("EXPECTED-BLOCK", tokenizer.block_type());
  24   EXPECT_EQ("MatchesAcceptedBlockType", tokenizer.data());
  25
  26   EXPECT_FALSE(tokenizer.GetNext());
  27 }
  28
  29 TEST(PEMTokenizerTest, CarriageReturnLineFeeds) {
  30   const char data[] =
  31       "-----BEGIN EXPECTED-BLOCK-----\r\n"
  32       "TWF0Y2hlc0FjY2VwdGVkQmxvY2tUeXBl\r\n"
  33       "-----END EXPECTED-BLOCK-----\r\n";
  34   base::StringPiece string_piece(data);
  35   std::vector<std::string> accepted_types;
  36   accepted_types.push_back("EXPECTED-BLOCK");
  37
  38   PEMTokenizer tokenizer(string_piece, accepted_types);
  39   EXPECT_TRUE(tokenizer.GetNext());
  40
  41   EXPECT_EQ("EXPECTED-BLOCK", tokenizer.block_type());
  42   EXPECT_EQ("MatchesAcceptedBlockType", tokenizer.data());
  43
  44   EXPECT_FALSE(tokenizer.GetNext());
  45 }
  46
  47 TEST(PEMTokenizerTest, NoAcceptedBlockTypes) {
  48   const char data[] =
  49       "-----BEGIN UNEXPECTED-BLOCK-----\n"
  50       "SWdub3Jlc1JlamVjdGVkQmxvY2tUeXBl\n"
  51       "-----END UNEXPECTED-BLOCK-----\n";
  52   base::StringPiece string_piece(data);
  53   std::vector<std::string> accepted_types;
  54   accepted_types.push_back("EXPECTED-BLOCK");
  55
  56   PEMTokenizer tokenizer(string_piece, accepted_types);
  57   EXPECT_FALSE(tokenizer.GetNext());
  58 }
  59
  60 TEST(PEMTokenizerTest, MultipleAcceptedBlockTypes) {
  61   const char data[] =
  62       "-----BEGIN BLOCK-ONE-----\n"
  63       "RW5jb2RlZERhdGFPbmU=\n"
  64       "-----END BLOCK-ONE-----\n"
  65       "-----BEGIN BLOCK-TWO-----\n"
  66       "RW5jb2RlZERhdGFUd28=\n"
  67       "-----END BLOCK-TWO-----\n";
  68   base::StringPiece string_piece(data);
  69   std::vector<std::string> accepted_types;
  70   accepted_types.push_back("BLOCK-ONE");
  71   accepted_types.push_back("BLOCK-TWO");
  72
  73   PEMTokenizer tokenizer(string_piece, accepted_types);
  74   EXPECT_TRUE(tokenizer.GetNext());
  75
  76   EXPECT_EQ("BLOCK-ONE", tokenizer.block_type());
  77   EXPECT_EQ("EncodedDataOne", tokenizer.data());
  78
  79   EXPECT_TRUE(tokenizer.GetNext());
  80
  81   EXPECT_EQ("BLOCK-TWO", tokenizer.block_type());
  82   EXPECT_EQ("EncodedDataTwo", tokenizer.data());
  83
  84   EXPECT_FALSE(tokenizer.GetNext());
  85 }
  86
  87 TEST(PEMTokenizerTest, MissingFooter) {
  88   const char data[] =
  89       "-----BEGIN MISSING-FOOTER-----\n"
  90       "RW5jb2RlZERhdGFPbmU=\n"
  91       "-----END MISSING-FOOTER-----\n"
  92       "-----BEGIN MISSING-FOOTER-----\n"
  93       "RW5jb2RlZERhdGFUd28=\n";
  94   base::StringPiece string_piece(data);
  95   std::vector<std::string> accepted_types;
  96   accepted_types.push_back("MISSING-FOOTER");
  97
  98   PEMTokenizer tokenizer(string_piece, accepted_types);
  99   EXPECT_TRUE(tokenizer.GetNext());
 100
 101   EXPECT_EQ("MISSING-FOOTER", tokenizer.block_type());
 102   EXPECT_EQ("EncodedDataOne", tokenizer.data());
 103
 104   EXPECT_FALSE(tokenizer.GetNext());
 105 }
 106
 107 TEST(PEMTokenizerTest, NestedEncoding) {
 108   const char data[] =
 109       "-----BEGIN BLOCK-ONE-----\n"
 110       "RW5jb2RlZERhdGFPbmU=\n"
 111       "-----BEGIN BLOCK-TWO-----\n"
 112       "RW5jb2RlZERhdGFUd28=\n"
 113       "-----END BLOCK-TWO-----\n"
 114       "-----END BLOCK-ONE-----\n"
 115       "-----BEGIN BLOCK-ONE-----\n"
 116       "RW5jb2RlZERhdGFUaHJlZQ==\n"
 117       "-----END BLOCK-ONE-----\n";
 118   base::StringPiece string_piece(data);
 119   std::vector<std::string> accepted_types;
 120   accepted_types.push_back("BLOCK-ONE");
 121
 122   PEMTokenizer tokenizer(string_piece, accepted_types);
 123   EXPECT_TRUE(tokenizer.GetNext());
 124
 125   EXPECT_EQ("BLOCK-ONE", tokenizer.block_type());
 126   EXPECT_EQ("EncodedDataThree", tokenizer.data());
 127
 128   EXPECT_FALSE(tokenizer.GetNext());
 129 }
 130
 131 TEST(PEMTokenizerTest, EmptyAcceptedTypes) {
 132   const char data[] =
 133       "-----BEGIN BLOCK-ONE-----\n"
 134       "RW5jb2RlZERhdGFPbmU=\n"
 135       "-----END BLOCK-ONE-----\n";
 136   base::StringPiece string_piece(data);
 137   std::vector<std::string> accepted_types;
 138
 139   PEMTokenizer tokenizer(string_piece, accepted_types);
 140   EXPECT_FALSE(tokenizer.GetNext());
 141 }
 142
 143 TEST(PEMTokenizerTest, BlockWithHeader) {
 144   const char data[] =
 145       "-----BEGIN BLOCK-ONE-----\n"
 146       "Header-One: Data data data\n"
 147       "Header-Two: \n"
 148       "  continuation\n"
 149       "Header-Three: Mix-And,Match\n"
 150       "\n"
 151       "RW5jb2RlZERhdGFPbmU=\n"
 152       "-----END BLOCK-ONE-----\n"
 153       "-----BEGIN BLOCK-ONE-----\n"
 154       "RW5jb2RlZERhdGFUd28=\n"
 155       "-----END BLOCK-ONE-----\n";
 156   base::StringPiece string_piece(data);
 157   std::vector<std::string> accepted_types;
 158   accepted_types.push_back("BLOCK-ONE");
 159
 160   PEMTokenizer tokenizer(string_piece, accepted_types);
 161   EXPECT_TRUE(tokenizer.GetNext());
 162
 163   EXPECT_EQ("BLOCK-ONE", tokenizer.block_type());
 164   EXPECT_EQ("EncodedDataTwo", tokenizer.data());
 165
 166   EXPECT_FALSE(tokenizer.GetNext());
 167 }
 168
 169 }  // namespace net