husc 0.1.0

data/vendor/bundle/gems/domain_name-0.5.20190701/lib/domain_name/etld_data.rb.erb

@@ -0,0 +1,11 @@
+class DomainName
+  ETLD_DATA_DATE = '<%= etld_data_date.utc.strftime('%Y-%m-%dT%H:%M:%SZ') %>'
+
+  ETLD_DATA = {
+<% etld_data.each_pair { |key, value| %>    <%= key.inspect %> => <%= value.inspect %>,
+<% } %>  }
+
+  def self.etld_data
+    ETLD_DATA
+  end
+end

data/vendor/bundle/gems/domain_name-0.5.20190701/lib/domain_name/punycode.rb

@@ -0,0 +1,283 @@
+# -*- coding: utf-8 -*-
+#--
+# punycode.rb - PunyCode encoder for the Domain Name library
+#
+# Copyright (C) 2011-2017 Akinori MUSHA, All rights reserved.
+#
+# Ported from puny.c, a part of VeriSign XCode (encode/decode) IDN
+# Library.
+#
+# Copyright (C) 2000-2002 Verisign Inc., All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the following
+# conditions are met:
+#
+#  1) Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#
+#  2) Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in
+#     the documentation and/or other materials provided with the
+#     distribution.
+#
+#  3) Neither the name of the VeriSign Inc. nor the names of its
+#     contributors may be used to endorse or promote products derived
+#     from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# This software is licensed under the BSD open source license. For more
+# information visit www.opensource.org.
+#
+# Authors:
+#  John Colosi (VeriSign)
+#  Srikanth Veeramachaneni (VeriSign)
+#  Nagesh Chigurupati (Verisign)
+#  Praveen Srinivasan(Verisign)
+#++
+
+class DomainName
+  module Punycode
+    BASE = 36
+    TMIN = 1
+    TMAX = 26
+    SKEW = 38
+    DAMP = 700
+    INITIAL_BIAS = 72
+    INITIAL_N = 0x80
+    DELIMITER = '-'.freeze
+
+    MAXINT = (1 << 32) - 1
+
+    LOBASE = BASE - TMIN
+    CUTOFF = LOBASE * TMAX / 2
+
+    RE_NONBASIC = /[^\x00-\x7f]/
+
+    # Returns the numeric value of a basic code point (for use in
+    # representing integers) in the range 0 to base-1, or nil if cp
+    # is does not represent a value.
+    DECODE_DIGIT = {}.tap { |map|
+      # ASCII A..Z map to 0..25
+      # ASCII a..z map to 0..25
+      (0..25).each { |i| map[65 + i] = map[97 + i] = i }
+      # ASCII 0..9 map to 26..35
+      (26..35).each { |i| map[22 + i] = i }
+    }
+
+    # Returns the basic code point whose value (when used for
+    # representing integers) is d, which must be in the range 0 to
+    # BASE-1.  The lowercase form is used unless flag is true, in
+    # which case the uppercase form is used.  The behavior is
+    # undefined if flag is nonzero and digit d has no uppercase
+    # form.
+    ENCODE_DIGIT = proc { |d, flag|
+      (d + 22 + (d < 26 ? 75 : 0) - (flag ? (1 << 5) : 0)).chr
+      #  0..25 map to ASCII a..z or A..Z
+      # 26..35 map to ASCII 0..9
+    }
+
+    DOT = '.'.freeze
+    PREFIX = 'xn--'.freeze
+
+    # Most errors we raise are basically kind of ArgumentError.
+    class ArgumentError < ::ArgumentError; end
+    class BufferOverflowError < ArgumentError; end
+
+    class << self
+      # Encode a +string+ in Punycode
+      def encode(string)
+        input = string.unpack('U*')
+        output = ''
+
+        # Initialize the state
+        n = INITIAL_N
+        delta = 0
+        bias = INITIAL_BIAS
+
+        # Handle the basic code points
+        input.each { |cp| output << cp.chr if cp < 0x80 }
+
+        h = b = output.length
+
+        # h is the number of code points that have been handled, b is the
+        # number of basic code points, and out is the number of characters
+        # that have been output.
+
+        output << DELIMITER if b > 0
+
+        # Main encoding loop
+
+        while h < input.length
+          # All non-basic code points < n have been handled already.  Find
+          # the next larger one
+
+          m = MAXINT
+          input.each { |cp|
+            m = cp if (n...m) === cp
+          }
+
+          # Increase delta enough to advance the decoder's <n,i> state to
+          # <m,0>, but guard against overflow
+
+          delta += (m - n) * (h + 1)
+          raise BufferOverflowError if delta > MAXINT
+          n = m
+
+          input.each { |cp|
+            # AMC-ACE-Z can use this simplified version instead
+            if cp < n
+              delta += 1
+              raise BufferOverflowError if delta > MAXINT
+            elsif cp == n
+              # Represent delta as a generalized variable-length integer
+              q = delta
+              k = BASE
+              loop {
+                t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
+                break if q < t
+                q, r = (q - t).divmod(BASE - t)
+                output << ENCODE_DIGIT[t + r, false]
+                k += BASE
+              }
+
+              output << ENCODE_DIGIT[q, false]
+
+              # Adapt the bias
+              delta = h == b ? delta / DAMP : delta >> 1
+              delta += delta / (h + 1)
+              bias = 0
+              while delta > CUTOFF
+                delta /= LOBASE
+                bias += BASE
+              end
+              bias += (LOBASE + 1) * delta / (delta + SKEW)
+
+              delta = 0
+              h += 1
+            end
+          }
+
+          delta += 1
+          n += 1
+        end
+
+        output
+      end
+
+      # Encode a hostname using IDN/Punycode algorithms
+      def encode_hostname(hostname)
+        hostname.match(RE_NONBASIC) or return hostname
+
+        hostname.split(DOT).map { |name|
+          if name.match(RE_NONBASIC)
+            PREFIX + encode(name)
+          else
+            name
+          end
+        }.join(DOT)
+      end
+
+      # Decode a +string+ encoded in Punycode
+      def decode(string)
+        # Initialize the state
+        n = INITIAL_N
+        i = 0
+        bias = INITIAL_BIAS
+
+        if j = string.rindex(DELIMITER)
+          b = string[0...j]
+
+          b.match(RE_NONBASIC) and
+            raise ArgumentError, "Illegal character is found in basic part: #{string.inspect}"
+
+          # Handle the basic code points
+
+          output = b.unpack('U*')
+          u = string[(j + 1)..-1]
+        else
+          output = []
+          u = string
+        end
+
+        # Main decoding loop: Start just after the last delimiter if any
+        # basic code points were copied; start at the beginning
+        # otherwise.
+
+        input = u.unpack('C*')
+        input_length = input.length
+        h = 0
+        out = output.length
+
+        while h < input_length
+          # Decode a generalized variable-length integer into delta,
+          # which gets added to i.  The overflow checking is easier
+          # if we increase i as we go, then subtract off its starting
+          # value at the end to obtain delta.
+
+          oldi = i
+          w = 1
+          k = BASE
+
+          loop {
+            digit = DECODE_DIGIT[input[h]] or
+            raise ArgumentError, "Illegal character is found in non-basic part: #{string.inspect}"
+            h += 1
+            i += digit * w
+            raise BufferOverflowError if i > MAXINT
+            t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
+            break if digit < t
+            w *= BASE - t
+            raise BufferOverflowError if w > MAXINT
+            k += BASE
+            h < input_length or raise ArgumentError, "Malformed input given: #{string.inspect}"
+          }
+
+          # Adapt the bias
+          delta = oldi == 0 ? i / DAMP : (i - oldi) >> 1
+          delta += delta / (out + 1)
+          bias = 0
+          while delta > CUTOFF
+            delta /= LOBASE
+            bias += BASE
+          end
+          bias += (LOBASE + 1) * delta / (delta + SKEW)
+
+          # i was supposed to wrap around from out+1 to 0, incrementing
+          # n each time, so we'll fix that now:
+
+          q, i = i.divmod(out + 1)
+          n += q
+          raise BufferOverflowError if n > MAXINT
+
+          # Insert n at position i of the output:
+
+          output[i, 0] = n
+
+          out += 1
+          i += 1
+        end
+        output.pack('U*')
+      end
+
+      # Decode a hostname using IDN/Punycode algorithms
+      def decode_hostname(hostname)
+        hostname.gsub(/(\A|#{Regexp.quote(DOT)})#{Regexp.quote(PREFIX)}([^#{Regexp.quote(DOT)}]*)/o) {
+          $1 << decode($2)
+        }
+      end
+    end
+  end
+end

data/vendor/bundle/gems/domain_name-0.5.20190701/lib/domain_name/version.rb

@@ -0,0 +1,3 @@
+class DomainName
+  VERSION = '0.5.20190701'
+end

data/vendor/bundle/gems/domain_name-0.5.20190701/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'domain_name'
+
+class Test::Unit::TestCase
+end

data/vendor/bundle/gems/domain_name-0.5.20190701/test/test_domain_name-punycode.rb

@@ -0,0 +1,97 @@
+require 'helper'
+
+class TestDomainName < Test::Unit::TestCase
+  test "encode labels just as listed in RFC 3492 #7.1 (slightly modified)" do
+    [
+      ['(A) Arabic (Egyptian)',
+        [0x0644, 0x064A, 0x0647, 0x0645, 0x0627, 0x0628, 0x062A, 0x0643, 0x0644,
+          0x0645, 0x0648, 0x0634, 0x0639, 0x0631, 0x0628, 0x064A, 0x061F],
+        'egbpdaj6bu4bxfgehfvwxn'],
+      ['(B) Chinese (simplified)',
+        [0x4ED6, 0x4EEC, 0x4E3A, 0x4EC0, 0x4E48, 0x4E0D, 0x8BF4, 0x4E2D, 0x6587],
+        'ihqwcrb4cv8a8dqg056pqjye'],
+      ['(C) Chinese (traditional)',
+        [0x4ED6, 0x5011, 0x7232, 0x4EC0, 0x9EBD, 0x4E0D, 0x8AAA, 0x4E2D, 0x6587],
+        'ihqwctvzc91f659drss3x8bo0yb'],
+      ['(D) Czech: Pro<ccaron>prost<ecaron>nemluv<iacute><ccaron>esky',
+        [0x0050, 0x0072, 0x006F, 0x010D, 0x0070, 0x0072, 0x006F, 0x0073, 0x0074,
+          0x011B, 0x006E, 0x0065, 0x006D, 0x006C, 0x0075, 0x0076, 0x00ED, 0x010D,
+          0x0065, 0x0073, 0x006B, 0x0079],
+        'Proprostnemluvesky-uyb24dma41a'],
+      ['(E) Hebrew',
+        [0x05DC, 0x05DE, 0x05D4, 0x05D4, 0x05DD, 0x05E4, 0x05E9, 0x05D5, 0x05D8,
+          0x05DC, 0x05D0, 0x05DE, 0x05D3, 0x05D1, 0x05E8, 0x05D9, 0x05DD, 0x05E2,
+          0x05D1, 0x05E8, 0x05D9, 0x05EA],
+        '4dbcagdahymbxekheh6e0a7fei0b'],
+      ['(F) Hindi (Devanagari)',
+      [0x092F, 0x0939, 0x0932, 0x094B, 0x0917, 0x0939, 0x093F, 0x0928, 0x094D,
+          0x0926, 0x0940, 0x0915, 0x094D, 0x092F, 0x094B, 0x0902, 0x0928, 0x0939,
+          0x0940, 0x0902, 0x092C, 0x094B, 0x0932, 0x0938, 0x0915, 0x0924, 0x0947,
+          0x0939, 0x0948, 0x0902],
+        'i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd'],
+      ['(G) Japanese (kanji and hiragana)',
+        [0x306A, 0x305C, 0x307F, 0x3093, 0x306A, 0x65E5, 0x672C, 0x8A9E, 0x3092,
+          0x8A71, 0x3057, 0x3066, 0x304F, 0x308C, 0x306A, 0x3044, 0x306E, 0x304B],
+        'n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa'],
+      ['(H) Korean (Hangul syllables)',
+        [0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774,
+          0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74,
+          0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C],
+        '989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5j' <<
+        'psd879ccm6fea98c'],
+      ['(I) Russian (Cyrillic)',
+        [0x043F, 0x043E, 0x0447, 0x0435, 0x043C, 0x0443, 0x0436, 0x0435, 0x043E,
+          0x043D, 0x0438, 0x043D, 0x0435, 0x0433, 0x043E, 0x0432, 0x043E, 0x0440,
+          0x044F, 0x0442, 0x043F, 0x043E, 0x0440, 0x0443, 0x0441, 0x0441, 0x043A,
+          0x0438],
+        'b1abfaaepdrnnbgefbadotcwatmq2g4l'],
+      ['(J) Spanish: Porqu<eacute>nopuedensimplementehablarenEspa<ntilde>ol',
+        [0x0050, 0x006F, 0x0072, 0x0071, 0x0075, 0x00E9, 0x006E, 0x006F, 0x0070,
+          0x0075, 0x0065, 0x0064, 0x0065, 0x006E, 0x0073, 0x0069, 0x006D, 0x0070,
+          0x006C, 0x0065, 0x006D, 0x0065, 0x006E, 0x0074, 0x0065, 0x0068, 0x0061,
+          0x0062, 0x006C, 0x0061, 0x0072, 0x0065, 0x006E, 0x0045, 0x0073, 0x0070,
+          0x0061, 0x00F1, 0x006F, 0x006C],
+        'PorqunopuedensimplementehablarenEspaol-fmd56a'],
+      ['(K) Vietnamese: T<adotbelow>isaoh<odotbelow>kh<ocirc>ngth<ecirchookabove>ch' <<
+        '<ihookabove>n<oacute>iti<ecircacute>ngVi<ecircdotbelow>t',
+        [0x0054, 0x1EA1, 0x0069, 0x0073, 0x0061, 0x006F, 0x0068, 0x1ECD, 0x006B,
+          0x0068, 0x00F4, 0x006E, 0x0067, 0x0074, 0x0068, 0x1EC3, 0x0063, 0x0068,
+          0x1EC9, 0x006E, 0x00F3, 0x0069, 0x0074, 0x0069, 0x1EBF, 0x006E, 0x0067,
+          0x0056, 0x0069, 0x1EC7, 0x0074],
+        'TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g'],
+      ['(L) 3<nen>B<gumi><kinpachi><sensei>',
+        [0x0033, 0x5E74, 0x0042, 0x7D44, 0x91D1, 0x516B, 0x5148, 0x751F],
+        '3B-ww4c5e180e575a65lsy2b'],
+      ['(M) <amuro><namie>-with-SUPER-MONKEYS',
+        [0x5B89, 0x5BA4, 0x5948, 0x7F8E, 0x6075, 0x002D, 0x0077, 0x0069, 0x0074,
+          0x0068, 0x002D, 0x0053, 0x0055, 0x0050, 0x0045, 0x0052, 0x002D, 0x004D,
+          0x004F, 0x004E, 0x004B, 0x0045, 0x0059, 0x0053],
+        '-with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n'],
+      ['(N) Hello-Another-Way-<sorezore><no><basho>',
+       [0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002D, 0x0041, 0x006E, 0x006F,
+          0x0074, 0x0068, 0x0065, 0x0072, 0x002D, 0x0057, 0x0061, 0x0079, 0x002D,
+          0x305D, 0x308C, 0x305E, 0x308C, 0x306E, 0x5834, 0x6240],
+        'Hello-Another-Way--fc4qua05auwb3674vfr0b'],
+      ['(O) <hitotsu><yane><no><shita>2',
+        [0x3072, 0x3068, 0x3064, 0x5C4B, 0x6839, 0x306E, 0x4E0B, 0x0032],
+        '2-u9tlzr9756bt3uc0v'],
+      ['(P) Maji<de>Koi<suru>5<byou><mae>',
+        [0x004D, 0x0061, 0x006A, 0x0069, 0x3067, 0x004B, 0x006F, 0x0069, 0x3059,
+          0x308B, 0x0035, 0x79D2, 0x524D],
+        'MajiKoi5-783gue6qz075azm5e'],
+      ['(Q) <pafii>de<runba>',
+        [0x30D1, 0x30D5, 0x30A3, 0x30FC, 0x0064, 0x0065, 0x30EB, 0x30F3, 0x30D0],
+        'de-jg4avhby1noc0d'],
+      ['(R) <sono><supiido><de>',
+        [0x305D, 0x306E, 0x30B9, 0x30D4, 0x30FC, 0x30C9, 0x3067],
+        'd9juau41awczczp'],
+      ['(S) -> $1.00 <-',
+         [0x002D, 0x003E, 0x0020, 0x0024, 0x0031, 0x002E, 0x0030, 0x0030, 0x0020,
+          0x003C, 0x002D],
+        '-> $1.00 <--']
+    ].each { |title, cps, punycode|
+      assert_equal punycode, DomainName::Punycode.encode(cps.pack('U*')), title
+      assert_equal cps.pack('U*').to_nfc, DomainName::Punycode.decode(punycode), title
+    }
+  end
+end

data/vendor/bundle/gems/domain_name-0.5.20190701/test/test_domain_name.rb

@@ -0,0 +1,317 @@
+# -*- coding: utf-8 -*-
+require 'helper'
+require 'ipaddr'
+
+class TestDomainName < Test::Unit::TestCase
+  test "raise ArgumentError if hostname starts with a dot" do
+    [
+      # Leading dot.
+      '.com',
+      '.example',
+      '.example.com',
+      '.example.example',
+    ].each { |hostname|
+      assert_raises(ArgumentError) { DomainName.new(hostname) }
+    }
+  end
+
+  test "accept a String-alike for initialization" do
+    Object.new.tap { |obj|
+      def obj.to_str
+        "Example.org"
+      end
+      assert_equal "example.org", DomainName.new(obj).hostname
+    }
+
+    Object.new.tap { |obj|
+      def obj.to_str
+        123
+      end
+      assert_raises(TypeError) { DomainName.new(obj) }
+    }
+
+    Object.new.tap { |obj|
+      assert_raises(TypeError) { DomainName.new(obj) }
+    }
+  end
+
+  test "parse canonical domain names correctly" do
+    [
+      # Mixed case.
+      ['COM', nil, false, 'com', true],
+      ['example.COM', 'example.com', true, 'com', true],
+      ['WwW.example.COM', 'example.com', true, 'com', true],
+      # Unlisted TLD.
+      ['example', 'example', false, 'example', false],
+      ['example.example', 'example.example', false, 'example', false],
+      ['b.example.example', 'example.example', false, 'example', false],
+      ['a.b.example.example', 'example.example', false, 'example', false],
+      # Listed, but non-Internet, TLD.
+      ['local', 'local', false, 'local', false],
+      ['example.local', 'example.local', false, 'local', false],
+      ['b.example.local', 'example.local', false, 'local', false],
+      ['a.b.example.local', 'example.local', false, 'local', false],
+      # TLD with only 1 rule.
+      ['biz', nil, false, 'biz', true],
+      ['domain.biz', 'domain.biz', true, 'biz', true],
+      ['b.domain.biz', 'domain.biz', true, 'biz', true],
+      ['a.b.domain.biz', 'domain.biz', true, 'biz', true],
+      # TLD with some 2-level rules.
+      ['com', nil, false, 'com', true],
+      ['example.com', 'example.com', true, 'com', true],
+      ['b.example.com', 'example.com', true, 'com', true],
+      ['a.b.example.com', 'example.com', true, 'com', true],
+      ['uk.com', nil, false, 'com', true],
+      ['example.uk.com', 'example.uk.com', true, 'com', true],
+      ['b.example.uk.com', 'example.uk.com', true, 'com', true],
+      ['a.b.example.uk.com', 'example.uk.com', true, 'com', true],
+      ['test.ac', 'test.ac', true, 'ac', true],
+      # TLD with only 1 (wildcard) rule.
+      ['bd', nil, false, 'bd', true],
+      ['c.bd', nil, false, 'bd', true],
+      ['b.c.bd', 'b.c.bd', true, 'bd', true],
+      ['a.b.c.bd', 'b.c.bd', true, 'bd', true],
+      # More complex TLD.
+      ['jp', nil, false, 'jp', true],
+      ['test.jp', 'test.jp', true, 'jp', true],
+      ['www.test.jp', 'test.jp', true, 'jp', true],
+      ['ac.jp', nil, false, 'jp', true],
+      ['test.ac.jp', 'test.ac.jp', true, 'jp', true],
+      ['www.test.ac.jp', 'test.ac.jp', true, 'jp', true],
+      ['kyoto.jp', nil, false, 'jp', true],
+      ['test.kyoto.jp', 'test.kyoto.jp', true, 'jp', true],
+      ['ide.kyoto.jp', nil, false, 'jp', true],
+      ['b.ide.kyoto.jp', 'b.ide.kyoto.jp', true, 'jp', true],
+      ['a.b.ide.kyoto.jp', 'b.ide.kyoto.jp', true, 'jp', true],
+      ['c.kobe.jp', nil, false, 'jp', true],
+      ['b.c.kobe.jp', 'b.c.kobe.jp', true, 'jp', true],
+      ['a.b.c.kobe.jp', 'b.c.kobe.jp', true, 'jp', true],
+      ['city.kobe.jp', 'city.kobe.jp', true, 'jp', true],
+      ['www.city.kobe.jp', 'city.kobe.jp', true, 'jp', true],
+      # TLD with a wildcard rule and exceptions.
+      ['ck', nil, false, 'ck', true],
+      ['test.ck', nil, false, 'ck', true],
+      ['b.test.ck', 'b.test.ck', true, 'ck', true],
+      ['a.b.test.ck', 'b.test.ck', true, 'ck', true],
+      ['www.ck', 'www.ck', true, 'ck', true],
+      ['www.www.ck', 'www.ck', true, 'ck', true],
+      # US K12.
+      ['us', nil, false, 'us', true],
+      ['test.us', 'test.us', true, 'us', true],
+      ['www.test.us', 'test.us', true, 'us', true],
+      ['ak.us', nil, false, 'us', true],
+      ['test.ak.us', 'test.ak.us', true, 'us', true],
+      ['www.test.ak.us', 'test.ak.us', true, 'us', true],
+      ['k12.ak.us', nil, false, 'us', true],
+      ['test.k12.ak.us', 'test.k12.ak.us', true, 'us', true],
+      ['www.test.k12.ak.us', 'test.k12.ak.us', true, 'us', true],
+      # IDN labels. (modified; currently DomainName always converts U-labels to A-labels)
+      ['食狮.com.cn', 'xn--85x722f.com.cn', true, 'cn', true],
+      ['食狮.公司.cn', 'xn--85x722f.xn--55qx5d.cn', true, 'cn', true],
+      ['www.食狮.公司.cn', 'xn--85x722f.xn--55qx5d.cn', true, 'cn', true],
+      ['shishi.公司.cn', 'shishi.xn--55qx5d.cn', true, 'cn', true],
+      ['公司.cn', nil, false, 'cn', true],
+      ['食狮.中国', 'xn--85x722f.xn--fiqs8s', true, 'xn--fiqs8s', true],
+      ['www.食狮.中国', 'xn--85x722f.xn--fiqs8s', true, 'xn--fiqs8s', true],
+      ['shishi.中国', 'shishi.xn--fiqs8s', true, 'xn--fiqs8s', true],
+      ['中国', nil, false, 'xn--fiqs8s', true],
+      # Same as above, but punycoded.
+      ['xn--85x722f.com.cn', 'xn--85x722f.com.cn', true, 'cn', true],
+      ['xn--85x722f.xn--55qx5d.cn', 'xn--85x722f.xn--55qx5d.cn', true, 'cn', true],
+      ['www.xn--85x722f.xn--55qx5d.cn', 'xn--85x722f.xn--55qx5d.cn', true, 'cn', true],
+      ['shishi.xn--55qx5d.cn', 'shishi.xn--55qx5d.cn', true, 'cn', true],
+      ['xn--55qx5d.cn', nil, false, 'cn', true],
+      ['xn--85x722f.xn--fiqs8s', 'xn--85x722f.xn--fiqs8s', true, 'xn--fiqs8s', true],
+      ['www.xn--85x722f.xn--fiqs8s', 'xn--85x722f.xn--fiqs8s', true, 'xn--fiqs8s', true],
+      ['shishi.xn--fiqs8s', 'shishi.xn--fiqs8s', true, 'xn--fiqs8s', true],
+      ['xn--fiqs8s', nil, false, 'xn--fiqs8s', true],
+    ].each { |hostname, domain, canonical, tld, canonical_tld|
+      dn = DomainName.new(hostname)
+      assert_equal(domain, dn.domain, hostname + ':domain')
+      assert_equal(canonical, dn.canonical?, hostname + ':canoninal?')
+      assert_equal(tld, dn.tld, hostname + ':tld')
+      assert_equal(canonical_tld, dn.canonical_tld?, hostname + ':canoninal_tld?')
+    }
+  end
+
+  test "compare hostnames correctly" do
+    [
+      ["foo.com", "abc.foo.com", 1],
+      ["COM", "abc.foo.com", 1],
+      ["abc.def.foo.com", "foo.com", -1],
+      ["abc.def.foo.com", "ABC.def.FOO.com", 0],
+      ["abc.def.foo.com", "bar.com", nil],
+    ].each { |x, y, v|
+      dx, dy = DomainName(x), DomainName(y)
+      [
+        [dx, y, v],
+        [dx, dy, v],
+        [dy, x, v ? -v : v],
+        [dy, dx, v ? -v : v],
+      ].each { |a, b, expected|
+        assert_equal expected, a <=> b
+        case expected
+        when 1
+          assert_equal(true,  a >  b)
+          assert_equal(true,  a >= b)
+          assert_equal(false, a == b)
+          assert_equal(false, a <= b)
+          assert_equal(false, a <  b)
+        when -1
+          assert_equal(true,  a <  b)
+          assert_equal(true,  a <= b)
+          assert_equal(false, a == b)
+          assert_equal(false, a >= b)
+          assert_equal(false, a >  b)
+        when 0
+          assert_equal(false, a <  b)
+          assert_equal(true,  a <= b)
+          assert_equal(true,  a == b)
+          assert_equal(true,  a >= b)
+          assert_equal(false, a >  b)
+        when nil
+          assert_equal(nil,   a <  b)
+          assert_equal(nil,   a <= b)
+          assert_equal(false, a == b)
+          assert_equal(nil,   a >= b)
+          assert_equal(nil,   a >  b)
+        end
+      }
+    }
+  end
+
+  test "check cookie domain correctly" do
+    {
+      'com' => [
+        ['com', false],
+        ['example.com', false],
+        ['foo.example.com', false],
+        ['bar.foo.example.com', false],
+      ],
+
+      'example.com' => [
+        ['com', false],
+        ['example.com', true],
+        ['foo.example.com', false],
+        ['bar.foo.example.com', false],
+      ],
+
+      'foo.example.com' => [
+        ['com', false],
+        ['example.com', true],
+        ['foo.example.com', true],
+        ['foo.Example.com', true],
+        ['bar.foo.example.com', false],
+        ['bar.Foo.Example.com', false],
+      ],
+
+      'b.sapporo.jp' => [
+        ['jp', false],
+        ['sapporo.jp', false],
+        ['b.sapporo.jp', false],
+        ['a.b.sapporo.jp', false],
+      ],
+
+      'b.c.sapporo.jp' => [
+        ['jp', false],
+        ['sapporo.jp', false],
+        ['c.sapporo.jp', false],
+        ['b.c.sapporo.jp', true],
+        ['a.b.c.sapporo.jp', false],
+      ],
+
+      'b.c.d.sapporo.jp' => [
+        ['jp', false],
+        ['sapporo.jp', false],
+        ['d.sapporo.jp', false],
+        ['c.d.sapporo.jp', true],
+        ['b.c.d.sapporo.jp', true],
+        ['a.b.c.d.sapporo.jp', false],
+      ],
+
+      'city.sapporo.jp' => [
+        ['jp', false],
+        ['sapporo.jp', false],
+        ['city.sapporo.jp', true],
+        ['a.city.sapporo.jp', false],
+      ],
+
+      'b.city.sapporo.jp' => [
+        ['jp', false],
+        ['sapporo.jp', false],
+        ['city.sapporo.jp', true],
+        ['b.city.sapporo.jp', true],
+        ['a.b.city.sapporo.jp', false],
+      ],
+    }.each_pair { |host, pairs|
+      dn = DomainName(host)
+      assert_equal(true, dn.cookie_domain?(host.upcase, true),     dn.to_s)
+      assert_equal(true, dn.cookie_domain?(host.downcase, true),   dn.to_s)
+      assert_equal(false, dn.cookie_domain?("www." << host, true), dn.to_s)
+      pairs.each { |domain, expected|
+        assert_equal(expected, dn.cookie_domain?(domain),             "%s - %s" % [dn.to_s, domain])
+        assert_equal(expected, dn.cookie_domain?(DomainName(domain)), "%s - %s" % [dn.to_s, domain])
+      }
+    }
+  end
+
+  test "parse IPv4 addresseses" do
+    a = '192.168.10.20'
+    dn = DomainName(a)
+    assert_equal(a, dn.hostname)
+    assert_equal(true, dn.ipaddr?)
+    assert_equal(IPAddr.new(a), dn.ipaddr)
+    assert_equal(true, dn.cookie_domain?(a))
+    assert_equal(true, dn.cookie_domain?(a, true))
+    assert_equal(true, dn.cookie_domain?(dn))
+    assert_equal(true, dn.cookie_domain?(dn, true))
+    assert_equal(false, dn.cookie_domain?('168.10.20'))
+    assert_equal(false, dn.cookie_domain?('20'))
+    assert_equal(nil, dn.superdomain)
+  end
+
+  test "parse IPv6 addresseses" do
+    a = '2001:200:dff:fff1:216:3eff:feb1:44d7'
+    b = '2001:0200:0dff:fff1:0216:3eff:feb1:44d7'
+    [b, b.upcase, "[#{b}]", "[#{b.upcase}]"].each { |host|
+      dn = DomainName(host)
+      assert_equal("[#{a}]", dn.uri_host)
+      assert_equal(a, dn.hostname)
+      assert_equal(true, dn.ipaddr?)
+      assert_equal(IPAddr.new(a), dn.ipaddr)
+      assert_equal(true, dn.cookie_domain?(host))
+      assert_equal(true, dn.cookie_domain?(host, true))
+      assert_equal(true, dn.cookie_domain?(dn))
+      assert_equal(true, dn.cookie_domain?(dn, true))
+      assert_equal(true, dn.cookie_domain?(a))
+      assert_equal(true, dn.cookie_domain?(a, true))
+      assert_equal(nil, dn.superdomain)
+    }
+  end
+
+  test "get superdomain" do
+    [
+      %w[www.sub.example.local sub.example.local example.local local],
+      %w[www.sub.example.com sub.example.com example.com com],
+    ].each { |domain, *superdomains|
+      dn = DomainName(domain)
+      superdomains.each { |superdomain|
+        sdn = DomainName(superdomain)
+        assert_equal sdn, dn.superdomain
+        dn = sdn
+      }
+      assert_equal nil, dn.superdomain
+    }
+  end
+
+  test "have idn methods" do
+    dn = DomainName("金八先生.B組.3年.日本語ドメイン名Example.日本")
+
+    assert_equal "xn--44q1cv48kq8x.xn--b-gf6c.xn--3-pj3b.xn--example-6q4fyliikhk162btq3b2zd4y2o.xn--wgv71a", dn.hostname
+    assert_equal "金八先生.b組.3年.日本語ドメイン名example.日本", dn.hostname_idn
+    assert_equal "xn--example-6q4fyliikhk162btq3b2zd4y2o.xn--wgv71a", dn.domain
+    assert_equal "日本語ドメイン名example.日本", dn.domain_idn
+    assert_equal "xn--wgv71a", dn.tld
+    assert_equal "日本", dn.tld_idn
+  end
+end