net: enable DnsRRResolver on Windows

net/base/dnsrr_resolver_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/dnsrr_resolver.h"
 
 #include "base/callback.h"
 #include "base/synchronization/lock.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 class DnsRRResolverTest : public testing::Test {
 };
 
-#if defined(OS_LINUX)
-
 class ExplodingCallback : public CallbackRunner<Tuple1<int> > {
  public:
   virtual void RunWithParams(const Tuple1<int>& params) {
     FAIL();
   }
 };
 
-// This test is disabled because it depends on the external network to pass.
-// However, it may be useful when chaging the code.
+// These tests are disabled because they depend on the external network to
+// pass. However, they may be useful when chaging the code.
+TEST_F(DnsRRResolverTest, DISABLED_ResolveReal) {
+  RRResponse response;
+  TestCompletionCallback callback;
+  DnsRRResolver resolver;
+  DnsRRResolver::Handle handle;
+
+  handle = resolver.Resolve("test.imperialviolet.org", 13172, 0,
+                            &callback, &response, 0, BoundNetLog());
+  ASSERT_TRUE(handle != DnsRRResolver::kInvalidHandle);
+  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_EQ(1u, response.rrdatas.size());
+  LOG(ERROR) << "result length " << response.rrdatas[0].size();
+  LOG(ERROR) << "result is " << response.rrdatas[0];
+}
+
+TEST_F(DnsRRResolverTest, DISABLED_ResolveReal2) {
+  RRResponse response;
+  TestCompletionCallback callback;
+  DnsRRResolver resolver;
+  DnsRRResolver::Handle handle;
+
+  handle = resolver.Resolve("google.com", kDNS_TXT, 0,
+                            &callback, &response, 0, BoundNetLog());
+  ASSERT_TRUE(handle != DnsRRResolver::kInvalidHandle);
+  ASSERT_EQ(OK, callback.WaitForResult());
+  ASSERT_EQ(1u, response.rrdatas.size());
+  LOG(ERROR) << "result length " << response.rrdatas[0].size();
+  LOG(ERROR) << "result is " << response.rrdatas[0];
+}
+
+
 TEST_F(DnsRRResolverTest, Resolve) {
   RRResponse response;
   TestCompletionCallback callback;
   DnsRRResolver resolver;
   DnsRRResolver::Handle handle;
 
   handle = resolver.Resolve("www.testing.notatld", kDNS_TESTING, 0,
                             &callback, &response, 0, BoundNetLog());
   ASSERT_TRUE(handle != DnsRRResolver::kInvalidHandle);
   ASSERT_EQ(OK, callback.WaitForResult());
   ASSERT_EQ(1u, response.rrdatas.size());
   ASSERT_STREQ("goats!", response.rrdatas[0].c_str());
   ASSERT_EQ(1u, resolver.requests());
   ASSERT_EQ(0u, resolver.cache_hits());
   ASSERT_EQ(0u, resolver.inflight_joins());
 
   // Test a cache hit.
   handle = resolver.Resolve("www.testing.notatld", kDNS_TESTING, 0,
                             &callback, &response, 0, BoundNetLog());
   ASSERT_TRUE(handle != DnsRRResolver::kInvalidHandle);
   ASSERT_EQ(OK, callback.WaitForResult());
   ASSERT_EQ(1u, response.rrdatas.size());
   ASSERT_STREQ("goats!", response.rrdatas[0].c_str());
   ASSERT_EQ(2u, resolver.requests());
   ASSERT_EQ(1u, resolver.cache_hits());
   ASSERT_EQ(0u, resolver.inflight_joins());
 
-  // Test that a callback is never made. This depends on there before another
+  // Test that a callback is never made. This depends on there being another
   // test after this one which will pump the MessageLoop.
   ExplodingCallback callback3;
   handle = resolver.Resolve("www.testing.notatld", kDNS_TESTING, 0,
                             &callback3, &response, 0, BoundNetLog());
   ASSERT_TRUE(handle != DnsRRResolver::kInvalidHandle);
   resolver.CancelResolve(handle);
   ASSERT_EQ(3u, resolver.requests());
   ASSERT_EQ(2u, resolver.cache_hits());
   ASSERT_EQ(0u, resolver.inflight_joins());
 
@@ skipping 18 matching lines @@
   handle2 = resolver.Resolve("nx.testing.notatld", kDNS_TESTING, 0,
                              &callback2, &response, 0, BoundNetLog());
   ASSERT_TRUE(handle2 != DnsRRResolver::kInvalidHandle);
   ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());
   ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback2.WaitForResult());
   ASSERT_EQ(6u, resolver.requests());
   ASSERT_EQ(2u, resolver.cache_hits());
   ASSERT_EQ(1u, resolver.inflight_joins());
 }
 
+#if defined(OS_POSIX)
 // This is a DNS packet resulting from querying a recursive resolver for a TXT
 // record for agl._pka.imperialviolet.org. You should be able to get a
 // replacement from a packet capture should it ever be needed.
 static const uint8 kExamplePacket[] = {
   0xce, 0xfe, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x06, 0x00, 0x01, 0x03,
   0x61, 0x67, 0x6c, 0x04, 0x5f, 0x70, 0x6b, 0x61, 0x0e, 0x69, 0x6d, 0x70, 0x65,
   0x72, 0x69, 0x61, 0x6c, 0x76, 0x69, 0x6f, 0x6c, 0x65, 0x74, 0x03, 0x6f, 0x72,
   0x67, 0x00, 0x00, 0x10, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x10, 0x00, 0x01, 0x00,
   0x00, 0x01, 0x2c, 0x00, 0x5e, 0x5d, 0x76, 0x3d, 0x70, 0x6b, 0x61, 0x31, 0x3b,
   0x66, 0x70, 0x72, 0x3d, 0x32, 0x41, 0x46, 0x30, 0x30, 0x33, 0x32, 0x42, 0x34,
@@ skipping 64 matching lines @@
        bit_to_corrupt++) {
     unsigned byte = bit_to_corrupt >> 3;
     unsigned bit = bit_to_corrupt & 7;
 
     memcpy(copy, kExamplePacket, sizeof(copy));
     copy[byte] ^= (1 << bit);
 
     response.ParseFromResponse(copy, sizeof(copy), kDNS_TXT);
   }
 }
-
-#endif  // OS_LINUX
+#endif
 
 }  // namespace net