| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2009 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/proxy/proxy_config_service_common_unittest.h" | |
| 6 | |
| 7 #include <string> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "net/proxy/proxy_config.h" | |
| 11 | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 namespace net { | |
| 15 | |
| 16 namespace { | |
| 17 | |
| 18 // Helper to verify that |expected_proxy| matches the first proxy conatined in | |
| 19 // |actual_proxies|, and that |actual_proxies| contains exactly one proxy. If | |
| 20 // either condition is untrue, then |*did_fail| is set to true, and | |
| 21 // |*failure_details| is filled with a description of the failure. | |
| 22 void MatchesProxyServerHelper(const char* failure_message, | |
| 23 const char* expected_proxy, | |
| 24 const ProxyList& actual_proxies, | |
| 25 ::testing::AssertionResult* failure_details, | |
| 26 bool* did_fail) { | |
| 27 // If |expected_proxy| is empty, then we expect |actual_proxies| to be so as | |
| 28 // well. | |
| 29 if (strlen(expected_proxy) == 0) { | |
| 30 if (!actual_proxies.IsEmpty()) { | |
| 31 *did_fail = true; | |
| 32 *failure_details | |
| 33 << failure_message << ". Was expecting no proxies but got " | |
| 34 << actual_proxies.size() << "."; | |
| 35 } | |
| 36 return; | |
| 37 } | |
| 38 | |
| 39 // Otherwise we check that |actual_proxies| holds a single matching proxy. | |
| 40 if (actual_proxies.size() != 1) { | |
| 41 *did_fail = true; | |
| 42 *failure_details | |
| 43 << failure_message << ". Was expecting exactly one proxy but got " | |
| 44 << actual_proxies.size() << "."; | |
| 45 return; | |
| 46 } | |
| 47 | |
| 48 ProxyServer actual_proxy = actual_proxies.Get(); | |
| 49 std::string actual_proxy_string; | |
| 50 if (actual_proxy.is_valid()) | |
| 51 actual_proxy_string = actual_proxy.ToURI(); | |
| 52 | |
| 53 if (std::string(expected_proxy) != actual_proxy_string) { | |
| 54 *failure_details | |
| 55 << failure_message << ". Was expecting: \"" << expected_proxy | |
| 56 << "\" but got: \"" << actual_proxy_string << "\""; | |
| 57 *did_fail = true; | |
| 58 } | |
| 59 } | |
| 60 | |
| 61 std::string FlattenProxyBypass(const ProxyBypassRules& bypass_rules) { | |
| 62 std::string flattened_proxy_bypass; | |
| 63 for (ProxyBypassRules::RuleList::const_iterator it = | |
| 64 bypass_rules.rules().begin(); | |
| 65 it != bypass_rules.rules().end(); ++it) { | |
| 66 if (!flattened_proxy_bypass.empty()) | |
| 67 flattened_proxy_bypass += ","; | |
| 68 flattened_proxy_bypass += (*it)->ToString(); | |
| 69 } | |
| 70 return flattened_proxy_bypass; | |
| 71 } | |
| 72 | |
| 73 } // namespace | |
| 74 | |
| 75 ProxyRulesExpectation::ProxyRulesExpectation( | |
| 76 ProxyConfig::ProxyRules::Type type, | |
| 77 const char* single_proxy, | |
| 78 const char* proxy_for_http, | |
| 79 const char* proxy_for_https, | |
| 80 const char* proxy_for_ftp, | |
| 81 const char* fallback_proxy, | |
| 82 const char* flattened_bypass_rules, | |
| 83 bool reverse_bypass) | |
| 84 : type(type), | |
| 85 single_proxy(single_proxy), | |
| 86 proxy_for_http(proxy_for_http), | |
| 87 proxy_for_https(proxy_for_https), | |
| 88 proxy_for_ftp(proxy_for_ftp), | |
| 89 fallback_proxy(fallback_proxy), | |
| 90 flattened_bypass_rules(flattened_bypass_rules), | |
| 91 reverse_bypass(reverse_bypass) { | |
| 92 } | |
| 93 | |
| 94 | |
| 95 ::testing::AssertionResult ProxyRulesExpectation::Matches( | |
| 96 const ProxyConfig::ProxyRules& rules) const { | |
| 97 ::testing::AssertionResult failure_details = ::testing::AssertionFailure(); | |
| 98 bool failed = false; | |
| 99 | |
| 100 if (rules.type != type) { | |
| 101 failure_details << "Type mismatch. Expected: " | |
| 102 << type << " but was: " << rules.type; | |
| 103 failed = true; | |
| 104 } | |
| 105 | |
| 106 MatchesProxyServerHelper("Bad single_proxy", single_proxy, | |
| 107 rules.single_proxies, &failure_details, &failed); | |
| 108 MatchesProxyServerHelper("Bad proxy_for_http", proxy_for_http, | |
| 109 rules.proxies_for_http, &failure_details, | |
| 110 &failed); | |
| 111 MatchesProxyServerHelper("Bad proxy_for_https", proxy_for_https, | |
| 112 rules.proxies_for_https, &failure_details, | |
| 113 &failed); | |
| 114 MatchesProxyServerHelper("Bad fallback_proxy", fallback_proxy, | |
| 115 rules.fallback_proxies, &failure_details, &failed); | |
| 116 | |
| 117 std::string actual_flattened_bypass = FlattenProxyBypass(rules.bypass_rules); | |
| 118 if (std::string(flattened_bypass_rules) != actual_flattened_bypass) { | |
| 119 failure_details | |
| 120 << "Bad bypass rules. Expected: \"" << flattened_bypass_rules | |
| 121 << "\" but got: \"" << actual_flattened_bypass << "\""; | |
| 122 failed = true; | |
| 123 } | |
| 124 | |
| 125 if (rules.reverse_bypass != reverse_bypass) { | |
| 126 failure_details << "Bad reverse_bypass. Expected: " << reverse_bypass | |
| 127 << " but got: " << rules.reverse_bypass; | |
| 128 failed = true; | |
| 129 } | |
| 130 | |
| 131 return failed ? failure_details : ::testing::AssertionSuccess(); | |
| 132 } | |
| 133 | |
| 134 // static | |
| 135 ProxyRulesExpectation ProxyRulesExpectation::Empty() { | |
| 136 return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_NO_RULES, | |
| 137 "", "", "", "", "", "", false); | |
| 138 } | |
| 139 | |
| 140 // static | |
| 141 ProxyRulesExpectation ProxyRulesExpectation::EmptyWithBypass( | |
| 142 const char* flattened_bypass_rules) { | |
| 143 return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_NO_RULES, | |
| 144 "", "", "", "", "", flattened_bypass_rules, | |
| 145 false); | |
| 146 } | |
| 147 | |
| 148 // static | |
| 149 ProxyRulesExpectation ProxyRulesExpectation::Single( | |
| 150 const char* single_proxy, | |
| 151 const char* flattened_bypass_rules) { | |
| 152 return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY, | |
| 153 single_proxy, "", "", "", "", | |
| 154 flattened_bypass_rules, false); | |
| 155 } | |
| 156 | |
| 157 // static | |
| 158 ProxyRulesExpectation ProxyRulesExpectation::PerScheme( | |
| 159 const char* proxy_http, | |
| 160 const char* proxy_https, | |
| 161 const char* proxy_ftp, | |
| 162 const char* flattened_bypass_rules) { | |
| 163 return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME, | |
| 164 "", proxy_http, proxy_https, proxy_ftp, "", | |
| 165 flattened_bypass_rules, false); | |
| 166 } | |
| 167 | |
| 168 // static | |
| 169 ProxyRulesExpectation ProxyRulesExpectation::PerSchemeWithSocks( | |
| 170 const char* proxy_http, | |
| 171 const char* proxy_https, | |
| 172 const char* proxy_ftp, | |
| 173 const char* socks_proxy, | |
| 174 const char* flattened_bypass_rules) { | |
| 175 return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME, | |
| 176 "", proxy_http, proxy_https, proxy_ftp, | |
| 177 socks_proxy, flattened_bypass_rules, false); | |
| 178 } | |
| 179 | |
| 180 // static | |
| 181 ProxyRulesExpectation ProxyRulesExpectation::PerSchemeWithBypassReversed( | |
| 182 const char* proxy_http, | |
| 183 const char* proxy_https, | |
| 184 const char* proxy_ftp, | |
| 185 const char* flattened_bypass_rules) { | |
| 186 return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME, | |
| 187 "", proxy_http, proxy_https, proxy_ftp, "", | |
| 188 flattened_bypass_rules, true); | |
| 189 } | |
| 190 | |
| 191 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master