public void AddRange_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() => CollectionUtils.AddRange <int>(null, null));
Assert.Throws <ArgumentNullException>(() => CollectionUtils.AddRange(null, new[] { 1, 2, 3 }));
Assert.Throws <ArgumentNullException>(() => CollectionUtils.AddRange(new LinkedList <int>(), null));
Assert.Throws <ArgumentNullException>(() => CollectionUtils.AddRange(new List <int>(), null));
}
public void AddRange(Type type)
{
var collection = CreateIntCollection(type);
CollectionUtils.AddRange(collection, new[] { 1, 2, 3 });
Assert.AreEqual(3, collection.Count);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, collection);
}
private ICollection <int> CreateIntCollection(Type type, int[] initialValues = null)
{
var collection = (ICollection <int>)Activator.CreateInstance(type);
if (initialValues != null)
{
CollectionUtils.AddRange(collection, initialValues);
}
return(collection);
}
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
IList <JsonProperty> properties = base.CreateProperties(type, memberSerialization);
JsonPropertyCollection c = new JsonPropertyCollection(type);
CollectionUtils.AddRange(c, (IEnumerable)properties.Where(m => m.PropertyName != "Root"));
return(c);
}
protected override IList <JsonProperty> CreateProperties(JsonObjectContract contract)
{
IList <JsonProperty> properties = base.CreateProperties(contract);
JsonPropertyCollection c = new JsonPropertyCollection();
CollectionUtils.AddRange(c, (IEnumerable)properties.Where(m => m.PropertyName != "Root"));
return(c);
}
public static JsonSerializer Create(JsonSerializerSettings settings)
{
JsonSerializer jsonSerializer = new JsonSerializer();
if (settings != null)
{
if (!CollectionUtils.IsNullOrEmpty <JsonConverter>((ICollection <JsonConverter>)settings.Converters))
{
CollectionUtils.AddRange <JsonConverter>((IList <JsonConverter>)jsonSerializer.Converters, (IEnumerable <JsonConverter>)settings.Converters);
}
jsonSerializer.TypeNameHandling = settings.TypeNameHandling;
jsonSerializer.TypeNameAssemblyFormat = settings.TypeNameAssemblyFormat;
jsonSerializer.PreserveReferencesHandling = settings.PreserveReferencesHandling;
jsonSerializer.ReferenceLoopHandling = settings.ReferenceLoopHandling;
jsonSerializer.MissingMemberHandling = settings.MissingMemberHandling;
jsonSerializer.ObjectCreationHandling = settings.ObjectCreationHandling;
jsonSerializer.NullValueHandling = settings.NullValueHandling;
jsonSerializer.DefaultValueHandling = settings.DefaultValueHandling;
jsonSerializer.ConstructorHandling = settings.ConstructorHandling;
jsonSerializer.Context = settings.Context;
jsonSerializer._checkAdditionalContent = settings._checkAdditionalContent;
jsonSerializer._formatting = settings._formatting;
jsonSerializer._dateFormatHandling = settings._dateFormatHandling;
jsonSerializer._dateTimeZoneHandling = settings._dateTimeZoneHandling;
jsonSerializer._dateParseHandling = settings._dateParseHandling;
jsonSerializer._culture = settings._culture;
jsonSerializer._maxDepth = settings._maxDepth;
jsonSerializer._maxDepthSet = settings._maxDepthSet;
if (settings.Error != null)
{
jsonSerializer.Error += settings.Error;
}
if (settings.ContractResolver != null)
{
jsonSerializer.ContractResolver = settings.ContractResolver;
}
if (settings.ReferenceResolver != null)
{
jsonSerializer.ReferenceResolver = settings.ReferenceResolver;
}
if (settings.Binder != null)
{
jsonSerializer.Binder = settings.Binder;
}
}
return(jsonSerializer);
}
protected virtual JsonObjectContract CreateObjectContract(Type objectType)
{
JsonObjectContract jsonObjectContract = new JsonObjectContract(objectType);
this.InitializeContract((JsonContract)jsonObjectContract);
bool serializableAttribute = this.IgnoreSerializableAttribute;
jsonObjectContract.MemberSerialization = JsonTypeReflector.GetObjectMemberSerialization(jsonObjectContract.NonNullableUnderlyingType, serializableAttribute);
CollectionUtils.AddRange <JsonProperty>((IList <JsonProperty>)jsonObjectContract.Properties, (IEnumerable <JsonProperty>) this.CreateProperties(jsonObjectContract.NonNullableUnderlyingType, jsonObjectContract.MemberSerialization));
JsonObjectAttribute jsonObjectAttribute = JsonTypeReflector.GetJsonObjectAttribute(jsonObjectContract.NonNullableUnderlyingType);
if (jsonObjectAttribute != null)
{
jsonObjectContract.ItemRequired = jsonObjectAttribute._itemRequired;
}
if (Enumerable.Any <ConstructorInfo>((IEnumerable <ConstructorInfo>)jsonObjectContract.NonNullableUnderlyingType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic), (Func <ConstructorInfo, bool>)(c => c.IsDefined(typeof(JsonConstructorAttribute), true))))
{
ConstructorInfo attributeConstructor = this.GetAttributeConstructor(jsonObjectContract.NonNullableUnderlyingType);
if (attributeConstructor != null)
{
jsonObjectContract.OverrideConstructor = attributeConstructor;
CollectionUtils.AddRange <JsonProperty>((IList <JsonProperty>)jsonObjectContract.ConstructorParameters, (IEnumerable <JsonProperty>) this.CreateConstructorParameters(attributeConstructor, jsonObjectContract.Properties));
}
}
else if (jsonObjectContract.MemberSerialization == MemberSerialization.Fields)
{
if (JsonTypeReflector.FullyTrusted)
{
jsonObjectContract.DefaultCreator = new Func <object>(jsonObjectContract.GetUninitializedObject);
}
}
else if (jsonObjectContract.DefaultCreator == null || jsonObjectContract.DefaultCreatorNonPublic)
{
ConstructorInfo parametrizedConstructor = this.GetParametrizedConstructor(jsonObjectContract.NonNullableUnderlyingType);
if (parametrizedConstructor != null)
{
jsonObjectContract.ParametrizedConstructor = parametrizedConstructor;
CollectionUtils.AddRange <JsonProperty>((IList <JsonProperty>)jsonObjectContract.ConstructorParameters, (IEnumerable <JsonProperty>) this.CreateConstructorParameters(parametrizedConstructor, jsonObjectContract.Properties));
}
}
return(jsonObjectContract);
}
public void AddRange()
{
List <int> ints = new List <int>();
CollectionUtils.AddRange(ints, new int[4]);
Assert.AreEqual(4, ints.Count);
ints = new List <int> {
1, 2
};
CollectionUtils.AddRange(ints, new List <int> {
3, 4
});
Assert.AreEqual(4, ints.Count);
Assert.AreEqual(1, ints[0]);
Assert.AreEqual(2, ints[1]);
Assert.AreEqual(3, ints[2]);
Assert.AreEqual(4, ints[3]);
}
protected override string DoProcessQuerySolicit(out CommonContentType contentType)
{
contentType = CommonContentType.ZIP;
Dictionary <string, DbAppendSelectWhereClause> selectClauses = new Dictionary <string, DbAppendSelectWhereClause>();
string beachActivityClause = null;
List <object> beachActivityParams = null;
string beachClause = null;
List <object> beachParams = null;
string beachActivityMonStationClause = null;
List <object> beachActivityMonStationParams = null;
string activityIndicatorClause = null;
List <object> activityIndicatorParams = null;
const string organizationAlias = "O";
const string beachAlias = "B";
const string beachActivityAlias = "BA";
const string beachActivityMonStationAlias = "BAMS";
const string activityIndicatorAlias = "AI";
if (_actualStartDate.HasValue)
{
beachActivityClause = AppendToDbClause(beachActivityClause, beachActivityAlias + "." + "ACTUALSTARTDATE >= ?");
beachActivityParams = CollectionUtils.Add(_actualStartDate.Value, beachActivityParams);
}
if (_actualStopDate.HasValue)
{
beachActivityClause = AppendToDbClause(beachActivityClause, beachActivityAlias + "." + "ACTUALSTOPDATE <= ?");
beachActivityParams = CollectionUtils.Add(_actualStopDate.Value, beachActivityParams);
}
if (!string.IsNullOrEmpty(_beachName))
{
beachClause = AppendToDbClause(beachClause, "UPPER(" + beachAlias + "." + "BEACHNAME) LIKE " + _baseDao.SqlConcat("'%'", "UPPER(?)", "'%'"));
beachParams = CollectionUtils.Add(_beachName, beachParams);
}
if (!string.IsNullOrEmpty(_beachIdentifier))
{
beachClause = AppendToDbClause(beachClause, "UPPER(" + beachAlias + "." + "BEACHIDENTIFIER) = UPPER(?)");
beachParams = CollectionUtils.Add(_beachIdentifier, beachParams);
}
if (!string.IsNullOrEmpty(_monitoringStationIdentifier))
{
beachActivityMonStationClause = AppendToDbClause(beachActivityMonStationClause, "UPPER(" + beachActivityMonStationAlias + "." + "MONITORINGSTATIONIDENTIFIER) = UPPER(?)");
beachActivityMonStationParams = CollectionUtils.Add(_monitoringStationIdentifier, beachActivityMonStationParams);
}
if (!string.IsNullOrEmpty(_beachAccessType))
{
beachClause = AppendToDbClause(beachClause, "UPPER(" + beachAlias + "." + "BEACHACCESSTYPE) = UPPER(?)");
beachParams = CollectionUtils.Add(_beachAccessType, beachParams);
}
if (!string.IsNullOrEmpty(_activityIndicatorType))
{
activityIndicatorClause = AppendToDbClause(activityIndicatorClause, "UPPER(" + activityIndicatorAlias + "." + "INDICATORTYPE) = UPPER(?)");
activityIndicatorParams = CollectionUtils.Add(_activityIndicatorType, activityIndicatorParams);
}
if (_activeAdvisoryIndicator.HasValue)
{
if (_activeAdvisoryIndicator.Value)
{
beachActivityClause = AppendToDbClause(beachActivityClause, beachActivityAlias + "." + "ACTUALSTOPDATE IS NULL");
}
}
if (beachActivityMonStationClause != null)
{
selectClauses.Add("NOTIF_BEACHACTIVITYMONSTATION", new DbAppendSelectWhereClause(beachActivityMonStationAlias, _baseDao, beachActivityMonStationClause, beachActivityMonStationParams));
beachActivityClause = AppendToDbClause(beachActivityClause,
string.Format("{2}.ID IN (SELECT {1}.ACTIVITY_ID FROM NOTIF_BEACHACTIVITYMONSTATION {1} WHERE {0})",
beachActivityMonStationClause, beachActivityMonStationAlias, beachActivityAlias));
CollectionUtils.AddRange(beachActivityMonStationParams, ref beachActivityParams);
}
if (activityIndicatorClause != null)
{
selectClauses.Add("NOTIF_ACTIVITYINDICATOR", new DbAppendSelectWhereClause(activityIndicatorAlias, _baseDao, activityIndicatorClause, activityIndicatorParams));
beachActivityClause = AppendToDbClause(beachActivityClause,
string.Format("{2}.ID IN (SELECT {1}.ACTIVITY_ID FROM NOTIF_ACTIVITYINDICATOR {1} WHERE {0})",
activityIndicatorClause, activityIndicatorAlias, beachActivityAlias));
CollectionUtils.AddRange(activityIndicatorParams, ref beachActivityParams);
}
if (beachActivityClause != null)
{
selectClauses.Add("NOTIF_BEACHACTIVITY", new DbAppendSelectWhereClause(beachActivityAlias, _baseDao, beachActivityClause, beachActivityParams));
beachClause = AppendToDbClause(beachClause, string.Format("{2}.ID IN (SELECT {1}.BEACH_ID FROM NOTIF_BEACHACTIVITY {1} WHERE {0})",
beachActivityClause, beachActivityAlias, beachAlias));
CollectionUtils.AddRange(beachActivityParams, ref beachParams);
}
if (beachClause != null)
{
selectClauses.Add("NOTIF_BEACH", new DbAppendSelectWhereClause(beachAlias, _baseDao, beachClause, beachParams));
}
AppendAuditLogEvent("Querying database for BEACHES data ...");
List <BeachDetailDataType> beachDetails = _objectsFromDatabase.LoadFromDatabase <BeachDetailDataType>(_baseDao, selectClauses);
List <OrganizationDetailDataType> organizationDetails = null;
if (!CollectionUtils.IsNullOrEmpty(beachDetails))
{
string organizationClause;
if (beachClause != null)
{
organizationClause =
string.Format("({2}.ID IN (SELECT DISTINCT OBR.ORGANIZATION_ID FROM NOTIF_ORGANIZATIONBEACHROLE OBR WHERE OBR.BEACH_ID IN (SELECT {1}.ID FROM NOTIF_BEACH {1} WHERE {0})))",
beachClause, beachAlias, organizationAlias);
selectClauses.Add("NOTIF_ORGANIZATION", new DbAppendSelectWhereClause(organizationAlias, _baseDao, organizationClause, beachParams));
}
else
{
organizationClause =
string.Format("({0}.ID IN (SELECT DISTINCT OBR.ORGANIZATION_ID FROM NOTIF_ORGANIZATIONBEACHROLE OBR))",
organizationAlias);
}
organizationDetails = _objectsFromDatabase.LoadFromDatabase <OrganizationDetailDataType>(_baseDao, selectClauses);
}
BeachDataSubmissionDataType data = new BeachDataSubmissionDataType();
data.BeachDetail = CollectionUtils.IsNullOrEmpty(beachDetails) ? null : beachDetails.ToArray();
data.OrganizationDetail = CollectionUtils.IsNullOrEmpty(organizationDetails) ? null : organizationDetails.ToArray();
AppendAuditLogEvent(GetQuerySolicitResultsString(data));
data.AfterLoadFromDatabase();
string submissionFile = GenerateQuerySolicitFileAndAddToTransaction(data);
return(submissionFile);
}
public void AddRangeThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() => CollectionUtils.AddRange(null, new List <int>()));
Assert.Throws <ArgumentNullException>(() => CollectionUtils.AddRange(new List <int>(), null));
}
