diff --git a/.gitmodules b/.gitmodules
index 51779cb..400b2ab 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,3 @@
 [submodule "test-data"]
 	path = test-data
-	url = git://github.com/maxmind/MaxMind-DB.git
+	url = https://github.com/maxmind/MaxMind-DB.git
diff --git a/.travis.yml b/.travis.yml
index adb0a6b..3fb27a1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,12 @@
 language: go
 
 go:
- - 1.4
- - 1.5
- - 1.6
  - 1.7
  - 1.8
+ - 1.9
+ - "1.10"
+ - 1.11
+ - 1.12
  - tip
 
 matrix:
@@ -13,12 +14,12 @@ matrix:
     - go: tip
 
 before_install:
-  - "if [[ $TRAVIS_GO_VERSION == 1.8 ]]; then go get -v github.com/golang/lint/golint; fi"
+  - "if [[ $TRAVIS_GO_VERSION == 1.11 ]]; then go get -u golang.org/x/lint/golint; fi"
 
 script:
   - go test -race -cpu 1,4 -v
   - go test -race -v -tags appengine
-  - "if [[ $TRAVIS_GO_VERSION == 1.8 ]]; then go vet ./...; fi"
-  - "if [[ $TRAVIS_GO_VERSION == 1.8 ]]; then golint .; fi"
+  - "if [[ $TRAVIS_GO_VERSION == 1.11 ]]; then go vet ./...; fi"
+  - "if [[ $TRAVIS_GO_VERSION == 1.11 ]]; then golint .; fi"
 
 sudo: false
diff --git a/debian/changelog b/debian/changelog
index 86e654c..eea0091 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,10 @@
+golang-github-oschwald-geoip2-golang (1.3.0-1) UNRELEASED; urgency=medium
+
+  * New upstream release.
+  * New upstream release.
+
+ -- Debian Janitor <janitor@jelmer.uk>  Sat, 29 Jun 2019 09:33:00 +0000
+
 golang-github-oschwald-geoip2-golang (1.1.0-4) unstable; urgency=medium
 
   * Team upload.
diff --git a/reader.go b/reader.go
index 7dbc5c8..671a50b 100644
--- a/reader.go
+++ b/reader.go
@@ -14,6 +14,71 @@ import (
 	"github.com/oschwald/maxminddb-golang"
 )
 
+// The Enterprise struct corresponds to the data in the GeoIP2 Enterprise
+// database.
+type Enterprise struct {
+	City struct {
+		Confidence uint8             `maxminddb:"confidence"`
+		GeoNameID  uint              `maxminddb:"geoname_id"`
+		Names      map[string]string `maxminddb:"names"`
+	} `maxminddb:"city"`
+	Continent struct {
+		Code      string            `maxminddb:"code"`
+		GeoNameID uint              `maxminddb:"geoname_id"`
+		Names     map[string]string `maxminddb:"names"`
+	} `maxminddb:"continent"`
+	Country struct {
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
+		Confidence        uint8             `maxminddb:"confidence"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+	} `maxminddb:"country"`
+	Location struct {
+		AccuracyRadius uint16  `maxminddb:"accuracy_radius"`
+		Latitude       float64 `maxminddb:"latitude"`
+		Longitude      float64 `maxminddb:"longitude"`
+		MetroCode      uint    `maxminddb:"metro_code"`
+		TimeZone       string  `maxminddb:"time_zone"`
+	} `maxminddb:"location"`
+	Postal struct {
+		Code       string `maxminddb:"code"`
+		Confidence uint8  `maxminddb:"confidence"`
+	} `maxminddb:"postal"`
+	RegisteredCountry struct {
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
+		Confidence        uint8             `maxminddb:"confidence"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+	} `maxminddb:"registered_country"`
+	RepresentedCountry struct {
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
+		Type              string            `maxminddb:"type"`
+	} `maxminddb:"represented_country"`
+	Subdivisions []struct {
+		Confidence uint8             `maxminddb:"confidence"`
+		GeoNameID  uint              `maxminddb:"geoname_id"`
+		IsoCode    string            `maxminddb:"iso_code"`
+		Names      map[string]string `maxminddb:"names"`
+	} `maxminddb:"subdivisions"`
+	Traits struct {
+		AutonomousSystemNumber       uint   `maxminddb:"autonomous_system_number"`
+		AutonomousSystemOrganization string `maxminddb:"autonomous_system_organization"`
+		ConnectionType               string `maxminddb:"connection_type"`
+		Domain                       string `maxminddb:"domain"`
+		IsAnonymousProxy             bool   `maxminddb:"is_anonymous_proxy"`
+		IsLegitimateProxy            bool   `maxminddb:"is_legitimate_proxy"`
+		IsSatelliteProvider          bool   `maxminddb:"is_satellite_provider"`
+		ISP                          string `maxminddb:"isp"`
+		Organization                 string `maxminddb:"organization"`
+		UserType                     string `maxminddb:"user_type"`
+	} `maxminddb:"traits"`
+}
+
 // The City struct corresponds to the data in the GeoIP2/GeoLite2 City
 // databases.
 type City struct {
@@ -27,9 +92,10 @@ type City struct {
 		Names     map[string]string `maxminddb:"names"`
 	} `maxminddb:"continent"`
 	Country struct {
-		GeoNameID uint              `maxminddb:"geoname_id"`
-		IsoCode   string            `maxminddb:"iso_code"`
-		Names     map[string]string `maxminddb:"names"`
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
 	} `maxminddb:"country"`
 	Location struct {
 		AccuracyRadius uint16  `maxminddb:"accuracy_radius"`
@@ -42,15 +108,17 @@ type City struct {
 		Code string `maxminddb:"code"`
 	} `maxminddb:"postal"`
 	RegisteredCountry struct {
-		GeoNameID uint              `maxminddb:"geoname_id"`
-		IsoCode   string            `maxminddb:"iso_code"`
-		Names     map[string]string `maxminddb:"names"`
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
 	} `maxminddb:"registered_country"`
 	RepresentedCountry struct {
-		GeoNameID uint              `maxminddb:"geoname_id"`
-		IsoCode   string            `maxminddb:"iso_code"`
-		Names     map[string]string `maxminddb:"names"`
-		Type      string            `maxminddb:"type"`
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
+		Type              string            `maxminddb:"type"`
 	} `maxminddb:"represented_country"`
 	Subdivisions []struct {
 		GeoNameID uint              `maxminddb:"geoname_id"`
@@ -72,20 +140,23 @@ type Country struct {
 		Names     map[string]string `maxminddb:"names"`
 	} `maxminddb:"continent"`
 	Country struct {
-		GeoNameID uint              `maxminddb:"geoname_id"`
-		IsoCode   string            `maxminddb:"iso_code"`
-		Names     map[string]string `maxminddb:"names"`
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
 	} `maxminddb:"country"`
 	RegisteredCountry struct {
-		GeoNameID uint              `maxminddb:"geoname_id"`
-		IsoCode   string            `maxminddb:"iso_code"`
-		Names     map[string]string `maxminddb:"names"`
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
 	} `maxminddb:"registered_country"`
 	RepresentedCountry struct {
-		GeoNameID uint              `maxminddb:"geoname_id"`
-		IsoCode   string            `maxminddb:"iso_code"`
-		Names     map[string]string `maxminddb:"names"`
-		Type      string            `maxminddb:"type"`
+		GeoNameID         uint              `maxminddb:"geoname_id"`
+		IsInEuropeanUnion bool              `maxminddb:"is_in_european_union"`
+		IsoCode           string            `maxminddb:"iso_code"`
+		Names             map[string]string `maxminddb:"names"`
+		Type              string            `maxminddb:"type"`
 	} `maxminddb:"represented_country"`
 	Traits struct {
 		IsAnonymousProxy    bool `maxminddb:"is_anonymous_proxy"`
@@ -228,6 +299,18 @@ func getDBType(reader *maxminddb.Reader) (databaseType, error) {
 	}
 }
 
+// Enterprise takes an IP address as a net.IP struct and returns an Enterprise
+// struct and/or an error. This is intended to be used with the GeoIP2
+// Enterprise database.
+func (r *Reader) Enterprise(ipAddress net.IP) (*Enterprise, error) {
+	if isEnterprise&r.databaseType == 0 {
+		return nil, InvalidMethodError{"Enterprise", r.Metadata().DatabaseType}
+	}
+	var enterprise Enterprise
+	err := r.mmdbReader.Lookup(ipAddress, &enterprise)
+	return &enterprise, err
+}
+
 // City takes an IP address as a net.IP struct and returns a City struct
 // and/or an error. Although this can be used with other databases, this
 // method generally should be used with the GeoIP2 or GeoLite2 City databases.
diff --git a/reader_test.go b/reader_test.go
index 4752034..41fe8c7 100644
--- a/reader_test.go
+++ b/reader_test.go
@@ -5,177 +5,225 @@ import (
 	"net"
 	"testing"
 
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-func TestGeoIP2(t *testing.T) { TestingT(t) }
-
-type MySuite struct{}
-
-var _ = Suite(&MySuite{})
-
-func (s *MySuite) TestReader(c *C) {
+func TestReader(t *testing.T) {
 	reader, err := Open("test-data/test-data/GeoIP2-City-Test.mmdb")
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 
 	defer reader.Close()
 
 	record, err := reader.City(net.ParseIP("81.2.69.160"))
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 
 	m := reader.Metadata()
-	c.Assert(m.BinaryFormatMajorVersion, Equals, uint(2))
-	c.Assert(m.BinaryFormatMinorVersion, Equals, uint(0))
-	c.Assert(m.BuildEpoch, Equals, uint(0x58f5327d))
-	c.Assert(m.DatabaseType, Equals, "GeoIP2-City")
-	c.Assert(m.Description, DeepEquals, map[string]string{
-		"en": "GeoIP2 City Test Database (fake GeoIP2 data, for example purposes only)",
-		"zh": "小型数据库",
-	})
-	c.Assert(m.IPVersion, Equals, uint(6))
-	c.Assert(m.Languages, DeepEquals, []string{"en", "zh"})
-	c.Assert(m.NodeCount, Equals, uint(1240))
-	c.Assert(m.RecordSize, Equals, uint(28))
-
-	c.Assert(record.City.GeoNameID, Equals, uint(2643743))
-	c.Assert(record.City.Names, DeepEquals, map[string]string{
-		"de":    "London",
-		"en":    "London",
-		"es":    "Londres",
-		"fr":    "Londres",
-		"ja":    "ロンドン",
-		"pt-BR": "Londres",
-		"ru":    "Лондон",
-	})
-	c.Assert(record.Continent.GeoNameID, Equals, uint(6255148))
-	c.Assert(record.Continent.Code, Equals, "EU")
-	c.Assert(record.Continent.Names, DeepEquals, map[string]string{
-		"de":    "Europa",
-		"en":    "Europe",
-		"es":    "Europa",
-		"fr":    "Europe",
-		"ja":    "ヨーロッパ",
-		"pt-BR": "Europa",
-		"ru":    "Европа",
-		"zh-CN": "欧洲",
-	})
-
-	c.Assert(record.Country.GeoNameID, Equals, uint(2635167))
-	c.Assert(record.Country.IsoCode, Equals, "GB")
-	c.Assert(record.Country.Names, DeepEquals, map[string]string{
-		"de":    "Vereinigtes Königreich",
-		"en":    "United Kingdom",
-		"es":    "Reino Unido",
-		"fr":    "Royaume-Uni",
-		"ja":    "イギリス",
-		"pt-BR": "Reino Unido",
-		"ru":    "Великобритания",
-		"zh-CN": "英国",
-	})
-
-	c.Assert(record.Location.AccuracyRadius, Equals, uint16(100))
-	c.Assert(record.Location.Latitude, Equals, 51.5142)
-	c.Assert(record.Location.Longitude, Equals, -0.0931)
-	c.Assert(record.Location.TimeZone, Equals, "Europe/London")
-
-	c.Assert(record.Subdivisions[0].GeoNameID, Equals, uint(6269131))
-	c.Assert(record.Subdivisions[0].IsoCode, Equals, "ENG")
-	c.Assert(record.Subdivisions[0].Names, DeepEquals, map[string]string{
-		"en":    "England",
-		"pt-BR": "Inglaterra",
-		"fr":    "Angleterre",
-		"es":    "Inglaterra",
-	})
-
-	c.Assert(record.RegisteredCountry.GeoNameID, Equals, uint(6252001))
-	c.Assert(record.RegisteredCountry.IsoCode, Equals, "US")
-	c.Assert(record.RegisteredCountry.Names, DeepEquals, map[string]string{
-		"de":    "USA",
-		"en":    "United States",
-		"es":    "Estados Unidos",
-		"fr":    "États-Unis",
-		"ja":    "アメリカ合衆国",
-		"pt-BR": "Estados Unidos",
-		"ru":    "США",
-		"zh-CN": "美国",
-	})
+	assert.Equal(t, uint(2), m.BinaryFormatMajorVersion)
+	assert.Equal(t, uint(0), m.BinaryFormatMinorVersion)
+	assert.NotZero(t, m.BuildEpoch)
+	assert.Equal(t, "GeoIP2-City", m.DatabaseType)
+	assert.Equal(t,
+		map[string]string{
+			"en": "GeoIP2 City Test Database (fake GeoIP2 data, for example purposes only)",
+			"zh": "小型数据库",
+		},
+		m.Description,
+	)
+	assert.Equal(t, uint(6), m.IPVersion)
+	assert.Equal(t, []string{"en", "zh"}, m.Languages)
+	assert.NotZero(t, m.NodeCount)
+	assert.Equal(t, uint(28), m.RecordSize)
+
+	assert.Equal(t, uint(2643743), record.City.GeoNameID)
+	assert.Equal(t,
+		map[string]string{
+			"de":    "London",
+			"en":    "London",
+			"es":    "Londres",
+			"fr":    "Londres",
+			"ja":    "ロンドン",
+			"pt-BR": "Londres",
+			"ru":    "Лондон",
+		},
+		record.City.Names,
+	)
+	assert.Equal(t, uint(6255148), record.Continent.GeoNameID)
+	assert.Equal(t, "EU", record.Continent.Code)
+	assert.Equal(t,
+		map[string]string{
+			"de":    "Europa",
+			"en":    "Europe",
+			"es":    "Europa",
+			"fr":    "Europe",
+			"ja":    "ヨーロッパ",
+			"pt-BR": "Europa",
+			"ru":    "Европа",
+			"zh-CN": "欧洲",
+		},
+		record.Continent.Names,
+	)
+
+	assert.Equal(t, uint(2635167), record.Country.GeoNameID)
+	assert.True(t, record.Country.IsInEuropeanUnion)
+	assert.Equal(t, "GB", record.Country.IsoCode)
+	assert.Equal(t,
+		map[string]string{
+			"de":    "Vereinigtes Königreich",
+			"en":    "United Kingdom",
+			"es":    "Reino Unido",
+			"fr":    "Royaume-Uni",
+			"ja":    "イギリス",
+			"pt-BR": "Reino Unido",
+			"ru":    "Великобритания",
+			"zh-CN": "英国",
+		},
+		record.Country.Names,
+	)
+
+	assert.Equal(t, uint16(100), record.Location.AccuracyRadius)
+	assert.Equal(t, 51.5142, record.Location.Latitude)
+	assert.Equal(t, -0.0931, record.Location.Longitude)
+	assert.Equal(t, "Europe/London", record.Location.TimeZone)
+
+	assert.Equal(t, uint(6269131), record.Subdivisions[0].GeoNameID)
+	assert.Equal(t, "ENG", record.Subdivisions[0].IsoCode)
+	assert.Equal(t,
+		map[string]string{
+			"en":    "England",
+			"pt-BR": "Inglaterra",
+			"fr":    "Angleterre",
+			"es":    "Inglaterra",
+		},
+		record.Subdivisions[0].Names,
+	)
+
+	assert.Equal(t, uint(6252001), record.RegisteredCountry.GeoNameID)
+	assert.False(t, record.RegisteredCountry.IsInEuropeanUnion)
+	assert.Equal(t, "US", record.RegisteredCountry.IsoCode)
+	assert.Equal(t,
+		map[string]string{
+			"de":    "USA",
+			"en":    "United States",
+			"es":    "Estados Unidos",
+			"fr":    "États-Unis",
+			"ja":    "アメリカ合衆国",
+			"pt-BR": "Estados Unidos",
+			"ru":    "США",
+			"zh-CN": "美国",
+		},
+		record.RegisteredCountry.Names,
+	)
+
+	assert.False(t, record.RepresentedCountry.IsInEuropeanUnion)
 }
 
-func (s *MySuite) TestMetroCode(c *C) {
+func TestMetroCode(t *testing.T) {
 	reader, err := Open("test-data/test-data/GeoIP2-City-Test.mmdb")
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 	defer reader.Close()
 
 	record, err := reader.City(net.ParseIP("216.160.83.56"))
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 
-	c.Assert(record.Location.MetroCode, Equals, uint(819))
+	assert.Equal(t, uint(819), record.Location.MetroCode)
 }
 
-func (s *MySuite) TestAnonymousIP(c *C) {
+func TestAnonymousIP(t *testing.T) {
 	reader, err := Open("test-data/test-data/GeoIP2-Anonymous-IP-Test.mmdb")
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 	defer reader.Close()
 
 	record, err := reader.AnonymousIP(net.ParseIP("1.2.0.0"))
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 
-	c.Assert(record.IsAnonymous, Equals, true)
+	assert.Equal(t, true, record.IsAnonymous)
 
-	c.Assert(record.IsAnonymousVPN, Equals, true)
-	c.Assert(record.IsHostingProvider, Equals, false)
-	c.Assert(record.IsPublicProxy, Equals, false)
-	c.Assert(record.IsTorExitNode, Equals, false)
+	assert.Equal(t, true, record.IsAnonymousVPN)
+	assert.Equal(t, false, record.IsHostingProvider)
+	assert.Equal(t, false, record.IsPublicProxy)
+	assert.Equal(t, false, record.IsTorExitNode)
 }
 
-func (s *MySuite) TestASN(c *C) {
+func TestASN(t *testing.T) {
 	reader, err := Open("test-data/test-data/GeoLite2-ASN-Test.mmdb")
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 	defer reader.Close()
 
 	record, err := reader.ASN(net.ParseIP("1.128.0.0"))
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 
-	c.Assert(record.AutonomousSystemNumber, Equals, uint(1221))
+	assert.Equal(t, uint(1221), record.AutonomousSystemNumber)
 
-	c.Assert(record.AutonomousSystemOrganization, Equals, "Telstra Pty Ltd")
+	assert.Equal(t, "Telstra Pty Ltd", record.AutonomousSystemOrganization)
 }
 
-func (s *MySuite) TestConnectionType(c *C) {
+func TestConnectionType(t *testing.T) {
 	reader, err := Open("test-data/test-data/GeoIP2-Connection-Type-Test.mmdb")
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 
 	defer reader.Close()
 
 	record, err := reader.ConnectionType(net.ParseIP("1.0.1.0"))
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
+
+	assert.Equal(t, "Cable/DSL", record.ConnectionType)
+}
+
+func TestCountry(t *testing.T) {
+	reader, err := Open("test-data/test-data/GeoIP2-Country-Test.mmdb")
+	assert.Nil(t, err)
+
+	defer reader.Close()
 
-	c.Assert(record.ConnectionType, Equals, "Cable/DSL")
+	record, err := reader.Country(net.ParseIP("81.2.69.160"))
+	assert.Nil(t, err)
+
+	assert.True(t, record.Country.IsInEuropeanUnion)
+	assert.False(t, record.RegisteredCountry.IsInEuropeanUnion)
+	assert.False(t, record.RepresentedCountry.IsInEuropeanUnion)
 }
 
-func (s *MySuite) TestDomain(c *C) {
+func TestDomain(t *testing.T) {
 	reader, err := Open("test-data/test-data/GeoIP2-Domain-Test.mmdb")
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 	defer reader.Close()
 
 	record, err := reader.Domain(net.ParseIP("1.2.0.0"))
-	c.Assert(err, IsNil)
-	c.Assert(record.Domain, Equals, "maxmind.com")
+	assert.Nil(t, err)
+	assert.Equal(t, "maxmind.com", record.Domain)
+}
+
+func TestEnterprise(t *testing.T) {
+	reader, err := Open("test-data/test-data/GeoIP2-Enterprise-Test.mmdb")
+	require.Nil(t, err)
+
+	defer reader.Close()
+
+	record, err := reader.Enterprise(net.ParseIP("74.209.24.0"))
+	require.Nil(t, err)
+
+	assert.Equal(t, uint8(11), record.City.Confidence)
+
+	assert.Equal(t, uint(14671), record.Traits.AutonomousSystemNumber)
+	assert.Equal(t, "FairPoint Communications", record.Traits.AutonomousSystemOrganization)
+	assert.Equal(t, "Cable/DSL", record.Traits.ConnectionType)
+	assert.Equal(t, "frpt.net", record.Traits.Domain)
 }
 
-func (s *MySuite) TestISP(c *C) {
+func TestISP(t *testing.T) {
 	reader, err := Open("test-data/test-data/GeoIP2-ISP-Test.mmdb")
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 	defer reader.Close()
 
 	record, err := reader.ISP(net.ParseIP("1.128.0.0"))
-	c.Assert(err, IsNil)
+	assert.Nil(t, err)
 
-	c.Assert(record.AutonomousSystemNumber, Equals, uint(1221))
+	assert.Equal(t, uint(1221), record.AutonomousSystemNumber)
 
-	c.Assert(record.AutonomousSystemOrganization, Equals, "Telstra Pty Ltd")
-	c.Assert(record.ISP, Equals, "Telstra Internet")
-	c.Assert(record.Organization, Equals, "Telstra Internet")
+	assert.Equal(t, "Telstra Pty Ltd", record.AutonomousSystemOrganization)
+	assert.Equal(t, "Telstra Internet", record.ISP)
+	assert.Equal(t, "Telstra Internet", record.Organization)
 }
 
 // This ensures the compiler does not optimize away the function call