public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var info = serializer.Deserialize <EeasySerialibleVersionOfDHCPv6ScopeAddressProperties>(reader);
DHCPv4ScopeAddressProperties result = null;
if (info.UseDynamicAddress == true)
{
DynamicRenewTime time = DynamicRenewTime.WithSpecificRange(
info.DynamicAddressHour.Value, info.DynamicAddressMinute.Value,
info.DynamicAddressReboundingInterval.Value, info.DynamicAddressLeaseInterval.Value);
result = new DHCPv4ScopeAddressProperties(info.Start, info.End, info.ExcludedAddresses,
time, info.NetworkMask,
reuseAddressIfPossible: info.ReuseAddressIfPossible, addressAllocationStrategy: info.AddressAllocationStrategy,
supportDirectUnicast: info.SupportDirectUnicast, acceptDecline: info.AcceptDecline, informsAreAllowd: info.InformsAreAllowd
);
}
else
{
result = new DHCPv4ScopeAddressProperties(info.Start, info.End, info.ExcludedAddresses,
renewalTime: info.RenewalTime, preferredLifetime: info.PreferredLifetime, leaseTime: info.LeaseTime, info.NetworkMask,
reuseAddressIfPossible: info.ReuseAddressIfPossible, addressAllocationStrategy: info.AddressAllocationStrategy,
supportDirectUnicast: info.SupportDirectUnicast, acceptDecline: info.AcceptDecline, informsAreAllowd: info.InformsAreAllowd
);
}
return(result);
}
public void DHCPv4ScopeAddressProperties_NextAddress()
{
Random random = new Random();
Int32 addressRange = random.Next(0, 255);
IPv4Address start = random.GetIPv4Address();
IPv4Address end = start + addressRange;
Int32 usedAddreessAmount = random.Next(0, addressRange - 1);
List <IPv4Address> usedAddress = new List <IPv4Address>();
List <IPv4Address> excludedAddresses = new List <IPv4Address>();
for (int i = 0; i < usedAddreessAmount; i++)
{
IPv4Address nextAddress = start + i;
if (random.NextBoolean() == true)
{
usedAddress.Add(nextAddress);
}
else
{
excludedAddresses.Add(nextAddress);
}
}
DHCPv4ScopeAddressProperties properties = new DHCPv4ScopeAddressProperties(start, end, excludedAddresses,
addressAllocationStrategy: DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next);
IPv4Address next = properties.GetValidAddresses(usedAddress);
IPv4Address expectedAddress = start + usedAddreessAmount;
Assert.Equal(expectedAddress, next);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DHCPv4ScopeAddressProperties item = (DHCPv4ScopeAddressProperties)value;
var model = new EeasySerialibleVersionOfDHCPv6ScopeAddressProperties
{
AcceptDecline = item.AcceptDecline,
AddressAllocationStrategy = item.AddressAllocationStrategy,
End = item.End,
InformsAreAllowd = item.InformsAreAllowd,
ReuseAddressIfPossible = item.ReuseAddressIfPossible,
Start = item.Start,
SupportDirectUnicast = item.SupportDirectUnicast,
PreferredLifetime = item.PreferredLifetime,
LeaseTime = item.LeaseTime,
RenewalTime = item.RenewalTime,
ExcludedAddresses = item.ExcludedAddresses,
NetworkMask = item.Mask == null ? new Byte?() : (Byte)item.Mask.GetSlashNotation(),
UseDynamicAddress = item.UseDynamicRewnewTime
};
if (model.UseDynamicAddress == true)
{
model.DynamicAddressHour = item.DynamicRenewTime.Hour;
model.DynamicAddressMinute = item.DynamicRenewTime.Minutes;
model.DynamicAddressReboundingInterval = (Int32)item.DynamicRenewTime.MinutesToRebound;
model.DynamicAddressLeaseInterval = (Int32)item.DynamicRenewTime.MinutesToEndOfLife;
}
serializer.Serialize(writer, model);
}
public void DHCPv4ScopeAddressProperties_IsAddressInRange(String startAddressRaw, String endAddressRaw, String targetAddressRaw, Boolean expectedResult)
{
IPv4Address start = IPv4Address.FromString(startAddressRaw);
IPv4Address end = IPv4Address.FromString(endAddressRaw);
IPv4Address target = IPv4Address.FromString(targetAddressRaw);
DHCPv4ScopeAddressProperties properties = new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>());
Boolean actual = properties.IsAddressInRange(target);
Assert.Equal(expectedResult, actual);
}
public static DHCPv4Packet AsRequestResponse(
DHCPv4Packet request,
DHCPv4Lease lease,
DHCPv4ScopeAddressProperties addressProperties,
IEnumerable <DHCPv4ScopeProperty> scopeProperties)
{
DHCPv4Packet packet = new DHCPv4Packet(DHCPv4MessagesTypes.Acknowledge, request)
{
YourIPAdress = lease.Address,
_isValid = true,
};
packet.SetIPHeader(request);
packet.AddOption(new DHCPv4PacketAddressOption(DHCPv4OptionTypes.ServerIdentifier, packet.Header.Source));
packet.AddOptions(lease, addressProperties, scopeProperties);
packet.AddOptions82AtTheEnd(request);
return(packet);
}
public void DHCPv4ScopeAddressProperties_IsAddressRangeBetween(
String startOwnRangeRaw, String endOwnRangeRaw,
String startOtherRangeRaw, String endOtherRangeRaw,
Boolean expectedResult
)
{
IPv4Address startOwn = IPv4Address.FromString(startOwnRangeRaw);
IPv4Address endOwn = IPv4Address.FromString(endOwnRangeRaw);
DHCPv4ScopeAddressProperties own = new DHCPv4ScopeAddressProperties(startOwn, endOwn, Array.Empty <IPv4Address>());
IPv4Address startOther = IPv4Address.FromString(startOtherRangeRaw);
IPv4Address endOther = IPv4Address.FromString(endOtherRangeRaw);
DHCPv4ScopeAddressProperties other = new DHCPv4ScopeAddressProperties(startOther, endOther, Array.Empty <IPv4Address>());
Boolean actual = own.IsAddressRangeBetween(other);
Assert.Equal(expectedResult, actual);
}
public void DHCPv4ScopeAddressProperties_RandomAddress()
{
Random random = new Random();
Int32 addressRange = random.Next(0, 255);
IPv4Address start = random.GetIPv4Address();
IPv4Address end = start + addressRange;
Int32 usedAddreessAmount = random.Next(0, addressRange - 1);
List <IPv4Address> usedAddress = new List <IPv4Address>();
List <IPv4Address> excludedAddresses = new List <IPv4Address>();
for (int i = 0; i < usedAddreessAmount; i++)
{
IPv4Address nextAddress = start + i;
if (random.NextBoolean() == true)
{
usedAddress.Add(nextAddress);
}
else
{
excludedAddresses.Add(nextAddress);
}
}
DHCPv4ScopeAddressProperties properties = new DHCPv4ScopeAddressProperties(start, end, excludedAddresses,
addressAllocationStrategy: DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Random);
Int32 checkAmount = random.Next(100, 200);
for (int i = 0; i < checkAmount; i++)
{
IPv4Address next = properties.GetValidAddresses(usedAddress);
Assert.DoesNotContain(next, usedAddress);
Assert.DoesNotContain(next, excludedAddresses);
Assert.True(start <= next);
Assert.True(end >= next);
}
}
public void SerializeAndDeserialize_WithoutDynamicRenew()
{
Random random = new Random();
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Converters.Add(new IPv4AddressJsonConverter());
settings.Converters.Add(new DHCPv4ScopeAddressPropertiesConverter());
var input = new DHCPv4ScopeAddressProperties(
IPv4Address.FromString("192.168.10.20"), IPv4Address.FromString("192.168.10.50"),
new List <IPv4Address> {
IPv4Address.FromString("192.168.10.30"), IPv4Address.FromString("192.168.10.34")
},
TimeSpan.FromMinutes(random.Next(10, 20)), TimeSpan.FromMinutes(random.Next(40, 60)), TimeSpan.FromMinutes(random.Next(80, 120)),
(Byte)random.Next(10, 30), random.NextBoolean(), DaAPI.Core.Scopes.ScopeAddressProperties <DHCPv4ScopeAddressProperties, IPv4Address> .AddressAllocationStrategies.Next, random.NextBoolean(), random.NextBoolean(), random.NextBoolean());
String serialized = JsonConvert.SerializeObject(input, settings);
var actual = JsonConvert.DeserializeObject <DHCPv4ScopeAddressProperties>(serialized, settings);
Assert.Equal(input, actual);
}
public void DHCPv4ScopeAddressProperties_AreTimeValueValid()
{
Random random = new Random();
IPv4Address start = random.GetIPv4Address();
IPv4Address end = random.GetIPv4AddressGreaterThan(start);
TimeSpan renewalTime = TimeSpan.FromMinutes(random.Next(10, 100));
TimeSpan preferredLifetime = renewalTime + TimeSpan.FromMinutes(random.Next(10, 100));
TimeSpan validLifetime = preferredLifetime + TimeSpan.FromMinutes(random.Next(10, 100));
DHCPv4ScopeAddressProperties validInput =
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: renewalTime, preferredLifetime: preferredLifetime, leaseTime: validLifetime);
Boolean shouldBeTrue = validInput.AreTimeValueValid();
Assert.True(shouldBeTrue);
List <DHCPv4ScopeAddressProperties> invalidInputs = new List <DHCPv4ScopeAddressProperties>
{
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: null, preferredLifetime: null, leaseTime: null),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: renewalTime, preferredLifetime: null, leaseTime: null),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: null, preferredLifetime: preferredLifetime, leaseTime: null),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: null, preferredLifetime: null, leaseTime: validLifetime),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: renewalTime, preferredLifetime: preferredLifetime, leaseTime: null),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: renewalTime, preferredLifetime: null, leaseTime: validLifetime),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: null, preferredLifetime: preferredLifetime, leaseTime: validLifetime),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: renewalTime, preferredLifetime: validLifetime, leaseTime: preferredLifetime),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: preferredLifetime, preferredLifetime: renewalTime, leaseTime: validLifetime),
new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(), renewalTime: validLifetime, preferredLifetime: preferredLifetime, leaseTime: renewalTime),
};
foreach (var item in invalidInputs)
{
Boolean shouldBeFalse = item.AreTimeValueValid();
Assert.False(shouldBeFalse);
}
}
public void DHCPv4ScopeAddressProperties_PoolExhausted()
{
Random random = new Random();
Int32 addressRange = random.Next(0, 255);
IPv4Address start = random.GetIPv4Address();
IPv4Address end = start + addressRange;
List <IPv4Address> usedAddress = new List <IPv4Address>();
List <IPv4Address> excludedAddresses = new List <IPv4Address>();
for (int i = 0; i < addressRange + 1; i++)
{
IPv4Address nextAddress = start + i;
if (random.NextBoolean() == true)
{
usedAddress.Add(nextAddress);
}
else
{
excludedAddresses.Add(nextAddress);
}
}
List <DHCPv4ScopeAddressProperties.AddressAllocationStrategies> strategies = new List <DHCPv4ScopeAddressProperties.AddressAllocationStrategies> {
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Random,
};
foreach (var item in strategies)
{
DHCPv4ScopeAddressProperties properties = new DHCPv4ScopeAddressProperties(start, end, excludedAddresses,
addressAllocationStrategy: item);
IPv4Address next = properties.GetValidAddresses(usedAddress);
Assert.Equal(IPv4Address.Empty, next);
}
}
public void DHCPv4ScopeAddressProperties_SingleAddressRange()
{
Random random = new Random();
List <DHCPv4ScopeAddressProperties.AddressAllocationStrategies> strategies = new List <DHCPv4ScopeAddressProperties.AddressAllocationStrategies> {
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Random,
};
IPv4Address start = random.GetIPv4Address();
IPv4Address end = start;
foreach (var item in strategies)
{
DHCPv4ScopeAddressProperties properties = new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>(),
addressAllocationStrategy: item);
IPv4Address next = properties.GetValidAddresses(Array.Empty <IPv4Address>());
Assert.Equal(start, next);
}
}
private void AddOptions(
DHCPv4Lease lease,
DHCPv4ScopeAddressProperties addressProperties,
IEnumerable <DHCPv4ScopeProperty> scopeProperties)
{
List <DHCPv4ScopeProperty> propertiesToInsert = new List <DHCPv4ScopeProperty>(scopeProperties);
if (addressProperties != null)
{
propertiesToInsert.Add(new DHCPv4AddressScopeProperty(DHCPv4OptionTypes.SubnetMask, IPv4Address.FromByteArray(addressProperties.Mask.GetBytes())));
}
Dictionary <DHCPv4OptionTypes, TimeSpan?> timeRelatedOptions = new Dictionary <DHCPv4OptionTypes, TimeSpan?>();
if (lease != null)
{
timeRelatedOptions.Add(DHCPv4OptionTypes.IPAddressLeaseTime, lease.End - DateTime.UtcNow);
timeRelatedOptions.Add(DHCPv4OptionTypes.RenewalTimeValue, lease.RenewSpan);
timeRelatedOptions.Add(DHCPv4OptionTypes.RebindingTimeValue, lease.RebindingSpan);
}
Int32 timeOptionIndex = 0;
foreach (var item in timeRelatedOptions)
{
if (item.Value.HasValue == false)
{
continue;
}
propertiesToInsert.Insert(timeOptionIndex++, new DHCPv4TimeScopeProperty(item.Key, false, item.Value.Value));
}
foreach (var item in propertiesToInsert)
{
switch (item.ValueType)
{
case DHCPv4ScopePropertyType.Address:
case DHCPv4ScopePropertyType.Subnet:
AddOption(new DHCPv4PacketAddressOption(item.OptionIdentifier, ((DHCPv4AddressScopeProperty)item).Address));
break;
case DHCPv4ScopePropertyType.AddressList:
AddOption(new DHCPv4PacketAddressListOption(item.OptionIdentifier, ((DHCPv4AddressListScopeProperty)item).Addresses));
break;
case DHCPv4ScopePropertyType.Time:
AddOption(new DHCPv4PacketTimeSpanOption(item.OptionIdentifier, ((DHCPv4TimeScopeProperty)item).Value, false));
break;
case DHCPv4ScopePropertyType.TimeOffset:
AddOption(new DHCPv4PacketTimeSpanOption(item.OptionIdentifier, ((DHCPv4TimeScopeProperty)item).Value, true));
break;
case DHCPv4ScopePropertyType.Byte:
AddOption(new DHCPv4PacketByteOption(item.OptionIdentifier, (Byte)(((DHCPv4NumericValueScopeProperty)item).Value)));
break;
case DHCPv4ScopePropertyType.UInt16:
AddOption(new DHCPv4PacketUInt16Option(item.OptionIdentifier, (UInt16)(((DHCPv4NumericValueScopeProperty)item).Value)));
break;
case DHCPv4ScopePropertyType.UInt32:
AddOption(new DHCPv4PacketUInt32Option(item.OptionIdentifier, (UInt32)(((DHCPv4NumericValueScopeProperty)item).Value)));
break;
case DHCPv4ScopePropertyType.Boolean:
AddOption(new DHCPv4PacketBooleanOption(item.OptionIdentifier, ((DHCPv4BooleanScopeProperty)item).Value));
break;
case DHCPv4ScopePropertyType.AddressAndMask:
throw new NotImplementedException();
case DHCPv4ScopePropertyType.Text:
AddOption(new DHCPv4PacketTextOption(item.OptionIdentifier, ((DHCPv4TextScopeProperty)item).Value));
break;
case DHCPv4ScopePropertyType.ByteArray:
//AddOption(new DHCPv4PacketRawByteOption(item.OptionIdentifier, ((DHCPv4RawByteScopeProperty)item).Value));
throw new NotImplementedException();
default:
break;
}
}
}
public void DHCPv4Scope_AddressPropertiesInherientce()
{
Random random = new Random();
for (int i = 0; i < 100; i++)
{
IPv4Address grantParentStart = random.GetIPv4Address();
IPv4Address grantParentEnd = random.GetIPv4AddressGreaterThan(grantParentStart);
List <IPv4Address> grantParentExcludedAddresses = random.GetIPv4AddressesBetween(grantParentStart, grantParentEnd);
TimeSpan grantParentValidLifeTime = TimeSpan.FromMinutes(random.Next());
TimeSpan grantParentPrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next());
TimeSpan grantParentRenewalTimePrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next());
Boolean grantParentReuseAddressIfPossible = random.NextBoolean();
DHCPv4ScopeAddressProperties.AddressAllocationStrategies grantParentAllocationStrategy = DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next;
Boolean grantParentSupportDirectUnicast = random.NextBoolean();
Boolean grantParentAcceptDecline = random.NextBoolean();
Boolean grantParentInformsAreAllowd = random.NextBoolean();
Byte grantParentSubnetMask = (Byte)random.Next(18, 25);
DHCPv4ScopeAddressProperties grantParentProperties = new DHCPv4ScopeAddressProperties(
grantParentStart, grantParentEnd, grantParentExcludedAddresses,
grantParentRenewalTimePrefferedValidLifeTime, grantParentPrefferedValidLifeTime, grantParentValidLifeTime,
grantParentSubnetMask,
grantParentReuseAddressIfPossible, grantParentAllocationStrategy,
grantParentInformsAreAllowd, grantParentAcceptDecline, grantParentInformsAreAllowd);
IPv4Address parentStart = random.GetIPv4Address();
IPv4Address parentEnd = random.GetIPv4AddressGreaterThan(parentStart);
List <IPv4Address> parentExcludedAddresses = random.GetIPv4AddressesBetween(parentStart, parentEnd);
TimeSpan?parentValidLifeTime = null;
TimeSpan?parentPrefferedValidLifeTime = null;
TimeSpan?parentRenewalTimePrefferedValidLifeTime = null;
Byte?parentSubnetMask = null;
Boolean?parentReuseAddressIfPossible = null;
DHCPv4ScopeAddressProperties.AddressAllocationStrategies?parentAllocationStrategy = null;
Boolean?parentSupportDirectUnicast = null;
Boolean?parentAcceptDecline = null;
Boolean?parentInformsAreAllowd = null;
if (random.NextBoolean() == true)
{
parentValidLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
parentPrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
parentRenewalTimePrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
parentSubnetMask = (Byte)random.Next(18, 25);
}
if (random.NextBoolean() == true)
{
parentReuseAddressIfPossible = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
parentAllocationStrategy = DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Random;
}
if (random.NextBoolean() == true)
{
parentSupportDirectUnicast = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
parentAcceptDecline = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
parentInformsAreAllowd = random.NextBoolean();
}
DHCPv4ScopeAddressProperties parentProperties = new DHCPv4ScopeAddressProperties(
parentStart, parentEnd, parentExcludedAddresses,
parentRenewalTimePrefferedValidLifeTime, parentPrefferedValidLifeTime, parentValidLifeTime,
parentSubnetMask,
parentReuseAddressIfPossible, parentAllocationStrategy,
parentInformsAreAllowd, parentAcceptDecline, parentInformsAreAllowd);
IPv4Address childStart = random.GetIPv4Address();
IPv4Address childEnd = random.GetIPv4AddressGreaterThan(childStart);
List <IPv4Address> childExcludedAddresses = random.GetIPv4AddressesBetween(childStart, childEnd);
TimeSpan?childValidLifeTime = null;
TimeSpan?childPrefferedValidLifeTime = null;
TimeSpan?childRenewalTimePrefferedValidLifeTime = null;
Byte?childSubnetMask = null;
Boolean?childReuseAddressIfPossible = null;
DHCPv4ScopeAddressProperties.AddressAllocationStrategies?childAllocationStrategy = null;
Boolean?childSupportDirectUnicast = random.NextDouble() > 0.5;
Boolean?childAcceptDecline = random.NextDouble() > 0.5;
Boolean?childInformsAreAllowd = random.NextDouble() > 0.5;
if (random.NextBoolean() == true)
{
childValidLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
childPrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
childRenewalTimePrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
childSubnetMask = (Byte)random.Next(18, 25);
}
if (random.NextBoolean() == true)
{
childReuseAddressIfPossible = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
childAllocationStrategy = DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Random;
}
if (random.NextBoolean() == true)
{
childSupportDirectUnicast = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
childAcceptDecline = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
childInformsAreAllowd = random.NextBoolean();
}
DHCPv4ScopeAddressProperties childProperties = new DHCPv4ScopeAddressProperties(
childStart, childEnd, childExcludedAddresses,
childRenewalTimePrefferedValidLifeTime, childPrefferedValidLifeTime, childValidLifeTime,
childSubnetMask,
childReuseAddressIfPossible, childAllocationStrategy,
childSupportDirectUnicast, childAcceptDecline, childInformsAreAllowd);
Guid grantParentId = Guid.NewGuid();
Guid parentId = Guid.NewGuid();
Guid childId = Guid.NewGuid();
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = grantParentId,
AddressProperties = grantParentProperties,
}),
new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = parentId,
ParentId = grantParentId,
AddressProperties = parentProperties,
}),
new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = childId,
ParentId = parentId,
AddressProperties = childProperties,
}),
};
DHCPv4RootScope rootScope = GetRootScope();
rootScope.Load(events);
DHCPv4Scope scope = rootScope.GetScopeById(childId);
DHCPv4ScopeAddressProperties actualProperties = scope.GetAddressProperties();
DHCPv4ScopeAddressProperties expectedProperties = new DHCPv4ScopeAddressProperties(
childStart, childEnd, grantParentExcludedAddresses.Union(parentExcludedAddresses).Union(childExcludedAddresses).Where(x => x.IsBetween(childStart, childEnd)),
childRenewalTimePrefferedValidLifeTime.HasValue == true ? childRenewalTimePrefferedValidLifeTime.Value : (parentRenewalTimePrefferedValidLifeTime.HasValue == true ? parentRenewalTimePrefferedValidLifeTime.Value : grantParentRenewalTimePrefferedValidLifeTime),
childPrefferedValidLifeTime.HasValue == true ? childPrefferedValidLifeTime.Value : (parentPrefferedValidLifeTime.HasValue == true ? parentPrefferedValidLifeTime.Value : grantParentPrefferedValidLifeTime),
childValidLifeTime.HasValue == true ? childValidLifeTime.Value : (parentValidLifeTime.HasValue == true ? parentValidLifeTime.Value : grantParentValidLifeTime),
childSubnetMask.HasValue == true ? childSubnetMask.Value : (parentSubnetMask.HasValue == true ? parentSubnetMask.Value : grantParentSubnetMask),
childReuseAddressIfPossible.HasValue == true ? childReuseAddressIfPossible.Value : (parentReuseAddressIfPossible.HasValue == true ? parentReuseAddressIfPossible.Value : grantParentReuseAddressIfPossible),
childAllocationStrategy.HasValue == true ? childAllocationStrategy.Value : (parentAllocationStrategy.HasValue == true ? parentAllocationStrategy.Value : grantParentAllocationStrategy),
childSupportDirectUnicast.HasValue == true ? childSupportDirectUnicast.Value : (parentSupportDirectUnicast.HasValue == true ? parentSupportDirectUnicast.Value : grantParentSupportDirectUnicast),
childAcceptDecline.HasValue == true ? childAcceptDecline.Value : (parentAcceptDecline.HasValue == true ? parentAcceptDecline.Value : grantParentAcceptDecline),
childInformsAreAllowd.HasValue == true ? childInformsAreAllowd.Value : (parentInformsAreAllowd.HasValue == true ? parentInformsAreAllowd.Value : grantParentInformsAreAllowd)
);
Assert.Equal(expectedProperties, actualProperties);
}
}
public void DHCPv4ScopeAddressProperties_ValueAreValidForRoot_WithDynamicRenew()
{
Random random = new Random();
IPv4Address start = random.GetIPv4Address();
IPv4Address end = random.GetIPv4AddressGreaterThan(start);
DynamicRenewTime time = DynamicRenewTime.WithDefaultRange(23, 10);
DHCPv4ScopeAddressProperties validProperties = new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
time,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
);
Boolean shouldBeValid = validProperties.ValueAreValidForRoot();
Assert.True(shouldBeValid);
Assert.True(validProperties.UseDynamicRewnewTime);
Assert.Equal(time, validProperties.DynamicRenewTime);
List <DHCPv4ScopeAddressProperties> invalidProperties = new List <DHCPv4ScopeAddressProperties>
{
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
time,
0,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
time,
24,
null,
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
time,
24,
random.NextBoolean(),
null,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
time,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
null, random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
time,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), null, random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
time,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), null
),
};
foreach (var item in invalidProperties)
{
Boolean shouldBeInvalid = item.ValueAreValidForRoot();
Assert.False(shouldBeInvalid);
Assert.True(item.UseDynamicRewnewTime);
}
}
public void DHCPv4ScopeAddressProperties_ValueAreValidForRoot()
{
Random random = new Random();
IPv4Address start = random.GetIPv4Address();
IPv4Address end = random.GetIPv4AddressGreaterThan(start);
TimeSpan renewalTime = TimeSpan.FromMinutes(random.Next(10, 100));
TimeSpan preferredLifetime = renewalTime + TimeSpan.FromMinutes(random.Next(10, 100));
TimeSpan validLifetime = preferredLifetime + TimeSpan.FromMinutes(random.Next(10, 100));
DHCPv4ScopeAddressProperties validProperties = new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, preferredLifetime, validLifetime,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
);
Boolean shouldBeValid = validProperties.ValueAreValidForRoot();
Assert.True(shouldBeValid);
List <DHCPv4ScopeAddressProperties> invalidProperties = new List <DHCPv4ScopeAddressProperties>
{
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
null, preferredLifetime, validLifetime,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, null, validLifetime,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, preferredLifetime, null,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, preferredLifetime, validLifetime,
0,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, preferredLifetime, validLifetime,
24,
null,
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, preferredLifetime, validLifetime,
24,
random.NextBoolean(),
null,
random.NextBoolean(), random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, preferredLifetime, validLifetime,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
null, random.NextBoolean(), random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, preferredLifetime, validLifetime,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), null, random.NextBoolean()
),
new DHCPv4ScopeAddressProperties(
start, end, Array.Empty <IPv4Address>(),
renewalTime, preferredLifetime, validLifetime,
24,
random.NextBoolean(),
DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
random.NextBoolean(), random.NextBoolean(), null
),
};
foreach (var item in invalidProperties)
{
Boolean shouldBeInvalid = item.ValueAreValidForRoot();
Assert.False(shouldBeInvalid);
Assert.False(item.UseDynamicRewnewTime);
}
}
