public virtual void ShouldEncodeDecodeAddressString()
 {
     AddressType addressType = new AddressType();
     var result2 = addressType.Encode("0034567890abcdef1234567890abcdef12345678").ToHex();
     var result3 = addressType.Decode(result2, typeof(string));
     Assert.Equal("0x0034567890abcdef1234567890abcdef12345678", result3);
 }

 public Address(string address1,string address2,string postCode,AddressType addressType)
 {
     this._address1 = address1;
     this._address2 = address2;
     this._postCode = postCode;
     this._addressType = addressType;
 }

 public static string GetAddress(string Host, AddressType AddressFormat)
 {
     string IPAddress = string.Empty;
     AddressFamily addrFamily = AddressFamily.InterNetwork;
     switch (AddressFormat)
     {
         case AddressType.IPv4:
             addrFamily = AddressFamily.InterNetwork;
             break;
         case AddressType.IPv6:
             addrFamily = AddressFamily.InterNetworkV6;
             break;
     }
     IPHostEntry IPE = Dns.GetHostEntry(Host);
     if (Host != IPE.HostName)
     {
         IPE = Dns.GetHostEntry(IPE.HostName);
     }
     foreach (IPAddress IPA in IPE.AddressList)
     {
         if (IPA.AddressFamily == addrFamily)
         {
             return IPA.ToString();
         }
     }
     return string.Empty;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="BaseAddress"/> class.
 /// </summary>
 /// <param name="region">The region.</param>
 /// <param name="address">The address.</param>
 /// <param name="size">The size.</param>
 /// <param name="prefetchable">if set to <c>true</c> [prefetchable].</param>
 public BaseAddress(AddressType region, uint address, uint size, bool prefetchable)
 {
     this.region = region;
     this.address = address;
     this.size = size;
     this.prefetchable = prefetchable;
 }

 public AddressRange(AddressType desc, Byte id, UInt32 low, UInt32 high)
 {
     this.PId = id;
     this.PDesc = desc;
     this.PLow = low;
     this.PHigh = high;
 }

 public SocksRequest(StreamTypes type, AddressType addrtype, string address, int port)
 {
     Type = addrtype;
     StreamType = type;
     Address = address;
     Port = port;
 }

 public EmployeeAddress(AddressType type, string streetAddress, string city, string state, string zip)
 {
     _type = type;
     _streetAddress = streetAddress;
     _city = city;
     _zip = zip;
 }

 public void AddAddressType(AddressType type)
 {
     if (!this.IsAddressType(type))
     {
         this.addressTypes.Add(type);
     }
 }

        internal Option(string displayName, int? addressId, AddressType? addressType, string postcode, OptionType optionType, Model.Link[] links)
        {
            if (string.IsNullOrWhiteSpace(displayName)) throw new ArgumentNullException("displayName");
            if (links == null) throw new ArgumentNullException("links");

            DisplayName = displayName;
            AddressId = addressId;
            AddressType = addressType;
            Postcode = postcode;
            OptionType = optionType;

            var newLinks = new List<Model.Link>();

            foreach (Model.Link link in links)
            {
                Model.Link newLink;

                switch (link.Rel)
                {
                    case "next":
                        newLink = new Link(link.Rel, link.Href);
                        break;
                    default:
                        newLink = link;
                        break;
                }

                newLinks.Add(newLink);
            }

            Links = newLinks.ToArray();
        }

        internal Response(ReturnCode result,
                          string postcode,
                          int? addressId,
                          AddressType? addressType,
                          MatchLevel matchLevel,
                          string[] postalAddress,
                          AddressElement[] postalAddressElements,
                          string[] geographicAddress,
                          AddressElement[] geographicAddressElements,
                          string[] vanityAddress,
                          AddressElement[] vanityAddressElements,
                          ReformattedAddressResult? reformattedAddressResult,
                          string[] reformattedAddress,
                          int totalOptions,
                          Option[] options,
                          Request input,
                          Model.Link[] links
            )
        {
            if (links == null) throw new ArgumentNullException("links");

            Result = result;
            Postcode = postcode;
            AddressId = addressId;
            AddressType = addressType;
            MatchLevel = matchLevel;
            PostalAddress = postalAddress;
            PostalAddressElements = postalAddressElements;
            GeographicAddress = geographicAddress;
            GeographicAddressElements = geographicAddressElements;
            VanityAddress = vanityAddress;
            VanityAddressElements = vanityAddressElements;
            ReformattedAddressResult = reformattedAddressResult;
            ReformattedAddress = reformattedAddress;
            TotalOptions = totalOptions;
            Options = options;
            Input = input;

            var newLinks = new List<Model.Link>();

            foreach (Model.Link link in links)
            {
                Model.Link newLink;

                switch (link.Rel)
                {
                    case "self":
                        newLink = new Model.PostcodeLookup.Link(link.Rel, link.Href);
                        break;
                    default:
                        newLink = link;
                        break;
                }

                newLinks.Add(newLink);
            }

            Links = newLinks.ToArray();
        }

        public void ParseAddressType_ReturnsCorrectString(AddressType addressType, string expected)
        {
            //act
            var result = EnumFactory.ParseAddressType(addressType);

            //assert
            result.Should().Be(expected);
        }

        public void EnumHelper_Parse_ReturnsCorrectEnum(string value, AddressType addressType)
        {
            //act
            var result = EnumHelper<AddressType>.Parse(value);

            //assert
            result.Should().Be(addressType);
        }

 public SocksRequest(StreamTypes type, AddressType addrtype, string address, int port)
 {
     Type = addrtype;
     StreamType = type;
     Address = address;
     Port = port;
     Error = SocksError.Granted;
     IPAddress p = this.IP; //get Error on the stack.
 }

 internal SmsMessage(int index, SmsMessageStatus status, string senderPhoneNumber, 
     AddressType addrType, DateTime timestamp, string body)
 {
     this.Index = index;
     this.Status = status;
     this.Number = senderPhoneNumber;
     this.Timestamp = timestamp;
     this.AddressType = addrType;
     this.Body = body;
 }

 public Address(byte[] data, AddressType type, Network network = null)
 {
     if (data.Length != ADDRESS_SIZE)
     {
         throw new ArgumentException("Invalid Address");
     }
     Data = data;
     Type = type;
     Network = (network ?? Network.Default);
 }

 // constructor for loading an EXISTING Address - This constructor DOES NOT create a new GUID
 public Address(Guid addressId, Guid personId, int streetNumber, string streetName, string addressCity, string addressState, string addressZip,
                AddressType addressType)
 {
     _addressId = addressId;
     _personId = personId;
     _streetNumber = streetNumber;
     _streetName = streetName;
     _addressCity = addressCity;
     _addressState = addressState;
     _addressZip = addressZip;
     _addressType = addressType;
 }

 public static IAddressType MapCustomerAddressTypeToAddressType(this AuthorizeNet.APICore.customerAddressType response)
 {
     var result = new AddressType();
     result.AddressLine1 = response.address;
     result.City = response.city;
     result.Company = response.company;
     result.Country = response.country;
     result.PhoneNumber = response.phoneNumber;
     result.PostalCode = response.zip;
     result.State = response.state;
     return result;
 }

        public virtual void SetAddress(Address address, AddressType type)
        {
            if (address == null) return;

            Addresses = Addresses ?? new HashSet<ClientAddress>();
            var customerAddress = Addresses.FirstOrDefault(x => Equals(x.Address, address));
            if (customerAddress == null)
            {
                customerAddress = new ClientAddress(this, address, type);
                Addresses.Add(customerAddress);
            }
            customerAddress.Address = address;
        }

 /// <summary>
 /// Converts a braintree address to a <see cref="IAddress"/>.
 /// </summary>
 /// <param name="address">
 /// The address.
 /// </param>
 /// <param name="addressType">
 /// The address type.
 /// </param>
 /// <returns>
 /// The <see cref="IAddress"/>.
 /// </returns>
 public static IAddress ToAddress(this global::Braintree.Address address, AddressType addressType)
 {
     return new Core.Models.Address()
                {
                    Name = string.Format("{0} {1}", address.FirstName, address.LastName),
                    Address1 = address.StreetAddress,
                    Locality = address.Locality,
                    Region = address.Region,
                    PostalCode = address.PostalCode,
                    CountryCode = address.CountryCodeAlpha2,
                    AddressType = addressType
                };
 }

 private Address GetAddress(int userId, AddressType type)
 {
     var address = _db.Addresses.FirstOrDefault(a => a.UserId == userId && a.AddressType == type);
     if (address == null)
     {
         address = new Address
         {
             AddressType = type,
             AddressId = 0,
             UserId = userId,
         };
     }
     return address;
 }