public void PassesFilter_WithIntAndMethod_ReturnsTrue(int toTest, IntFilter.IntFilterMethods method, bool expected)
{
var filter = new IntFilter(method, 10);
var result = filter.PassesFilter(toTest);
Assert.Equal(expected, result);
}
public void when_requesting_major_int_returns_correct_sql_string_bis()
{
var filter = new IntFilter("counter", 1, IntFilterMode.Major);
var result = filter.GetMySqlString();
Assert.That(result, Is.EqualTo("counter > 1"));
}
public void PassesFilter_WithValidStringAndMethod_ReturnsTrue()
{
var filter = new IntFilter(IntFilter.IntFilterMethods.Greater, 10);
var result = filter.PassesFilter("20");
Assert.True(result);
}
public void FilterDigits_TestArrayAndFilter_ArgumentException()
{
int[] testArray = { 9, 25, 7, 2817, 19, 0, 777 };
int filter = 782;
int[] actualArray = IntFilter.FilterDigit(filter, testArray);
}
public IntFilterStrategy(IntFilter filter,
ComboBox conditionComboBox,
TextBox valueTextBox,
GroupBox filterGroupBox,
DockPanel valueDockPanel)
: base(conditionComboBox, valueTextBox, filterGroupBox, valueDockPanel)
{
this.Filter = filter;
}
public void FilterDigit_IntMinTestArrayAndFilter_ExpectedArray()
{
int[] testArray = { Int32.MinValue };
int filter = 7;
int[] expectedArray = { Int32.MinValue };
int[] actualArray = IntFilter.FilterDigit(filter, testArray);
CollectionAssert.AreEqual(expectedArray, actualArray);
}
public void FilterDigit_TestArrayAndFilter_ExpectedArray()
{
int[] testArray = { 9, 25, 7, 2817, 19, 0, 777, -7 };
int filter = 7;
int[] expectedArray = { 7, 2817, 777, -7 };
int[] actualArray = IntFilter.FilterDigit(filter, testArray);
CollectionAssert.AreEqual(expectedArray, actualArray);
}
public static int[] FilterArrayOfInts(int[]ints, IntFilter filter)
{
ArrayList aList = new ArrayList();
foreach (int i in ints)
{
if (filter(i))
{
aList.Add(i);
}
}
return ((int[])aList.ToArray(typeof(int)));
}
static public void RemoveEachSecondItem(ref IHuman list, IntFilter filter)
{
while (list.Length() == 1)
{
for (int i = 1; i <= list.Length(); i++)
{
if (filter(i))
{
list.Remove(i);
}
}
}
}
public static List <int> FilterListOfInt(int[] ints, IntFilter filter)
{
List <int> alist = new List <int>();
foreach (int i in ints)
{
if (filter(i))
{
alist.Add(i);
}
}
return(alist);
}
public static int[] FilterArrayOfInts(int[] ints, IntFilter filter)
{
ArrayList aList = new ArrayList();
foreach (int i in ints)
{
if (filter(i))
{
aList.Add(i);
}
}
return((int[])aList.ToArray(typeof(int)));
}
public static ISqlFilter SqlIntFilter(UserFilterProviderColumn columnFilter)
{
string column = "counter";
int? filterValue = null;
while (!filterValue.HasValue)
{
Console.WriteLine(" Inserisci il counter:");
var str = Console.ReadLine();
if (int.TryParse(str, out var value))
{
filterValue = value;
}
}
IntFilterMode?mode = null; //non è più un enum ma un oggetto che ha un enum ma che può essere nullo
while (mode == null)
{
Console.WriteLine("1. minore");
Console.WriteLine("2. uguale");
Console.WriteLine("3. maggiore");
var key = Console.ReadKey();
switch (key.KeyChar)
{
case '1':
mode = IntFilterMode.Minor;
break;
case '2':
mode = IntFilterMode.Equal;
break;
case '3':
mode = IntFilterMode.Major;
break;
}
}
var filter = new IntFilter(column, filterValue.Value, mode.Value);
return(filter);
}
private IEnumerable <Expression <Func <Person, bool> > > CreateWhereClausesFromFilter(PersonFilter filter)
{
var clauses = new List <Expression <Func <Person, bool> > >();
if (filter.NameFilters.Any())
{
foreach (StringFilter nameFilter in filter.NameFilters)
{
StringFilter localFilter = nameFilter;
if (nameFilter.Operator == Operator.Equals)
{
clauses.Add(person => person.Name.ToLowerInvariant() == localFilter.Value.ToLowerInvariant());
}
else if (nameFilter.Operator == Operator.Contains)
{
clauses.Add(person => person.Name.ToLowerInvariant().Contains(localFilter.Value.ToLowerInvariant()));
}
}
}
if (filter.AgeFilters.Any())
{
foreach (IntFilter ageFilter in filter.AgeFilters)
{
IntFilter localFilter = ageFilter;
if (ageFilter.Operator == Operator.Equals)
{
clauses.Add(person => person.Age == localFilter.Value);
}
else if (ageFilter.Operator == Operator.GreaterThan)
{
clauses.Add(person => person.Age > localFilter.Value);
}
else if (ageFilter.Operator == Operator.LessThan)
{
clauses.Add(person => person.Age < localFilter.Value);
}
}
}
return(clauses);
}
static public List <string> GetFiltersWheres <TFilters>(TFilters Filters)
where TFilters : new()
{
// TODO a way to exclude some Filters[something] from this mapping
// TODO check if all filters are parsed
// TODO check if Filters[something] is a prop of TEntity (otherwise skip/throw)
List <string> filtersWheres = new();
// TODO improve readability this "filter" is everywhere and is unclear what it means
PropertyInfo[] filtersProperties = typeof(TFilters).GetProperties();
foreach (var filterProperty in filtersProperties)
{
// Filters[prop] type LIST Filter<Int/String/Date>
var singleFilterList = filterProperty.GetValue(Filters);
// STRING FilterStringDto
if (singleFilterList is List <FilterStringDto> stringFilters)
{
foreach (var filterString in stringFilters)
{
var filter = new StringFilter
{
EntityProperty = filterProperty.Name,
Comparison = filterString.Comparison,
Value = filterString.Value,
};
filtersWheres.Add(filter.ToSql());
}
}
// INT FilterIntDto
else if (singleFilterList is List <FilterIntDto> intFilters)
{
foreach (var intFilter in intFilters)
{
var filter = new IntFilter
{
EntityProperty = filterProperty.Name,
Comparison = intFilter.Comparison,
Value = intFilter.Value,
};
filtersWheres.Add(filter.ToSql());
}
}
// DATE FilterDateDto
else if (singleFilterList is List <FilteDateDto> dateFilters)
{
foreach (var dateFilter in dateFilters)
{
var filter = new DateFilter
{
EntityProperty = filterProperty.Name,
Comparison = dateFilter.Comparison,
Value = dateFilter.Value,
};
filtersWheres.Add(filter.ToSql());
}
}
}
return(filtersWheres);
}
public void PassesFilter_WithNonInt_ThrowArgumentException()
{
var filter = new IntFilter(IntFilter.IntFilterMethods.Equal, 10);
Assert.Throws <ArgumentException>(() => filter.PassesFilter(new object()));
}
public void PassesFilter_WithInvalidStringAndMethod_ThrowsFormatException()
{
var filter = new IntFilter(IntFilter.IntFilterMethods.Greater, 10);
Assert.Throws <FormatException>(() => filter.PassesFilter("not_a_number"));
}
public void PassesFilter_WithIntAndNullMethod_ThrowsInvalidOperationException()
{
var filter = new IntFilter();
Assert.Throws <InvalidOperationException>(() => filter.PassesFilter(10));
}
public void FilterDigit_NullAndFilter_ArgumentNullException()
{
int filter = 7;
int[] actualArray = IntFilter.FilterDigit(filter, null);
}
