public void Duplicates_Should_Not_Be_Added()
{
var target = new Classes();
target.Add("foo");
target.Add("foo");
Assert.Equal(new[] { "foo" }, target);
}
public void WriteClass(Class cls)
{
cls.AllTypesAreResolved = !_visibility;
Classes.Add(cls);
if (_visibility)
{
writeSignature("class", cls, new[] { "typesearch" });
}
}
public void Duplicates_Should_Not_Be_Inserted_Via_InsertRange()
{
var target = new Classes();
target.Add("foo");
target.InsertRange(1, new[] { "foo", "bar" });
Assert.Equal(new[] { "foo", "bar" }, target);
}
public void Duplicates_Should_Not_Be_Inserted()
{
var target = new Classes();
target.Add("foo");
target.Insert(0, "foo");
Assert.Equal(new[] { "foo" }, target);
}
public Minimal(GenDataBase genDataBase)
{
GenDataBase = genDataBase;
Classes.Add("Class");
Classes.Add("SubClass");
Classes.Add("Property");
SubClasses.Add("Class");
base.GenObject = genDataBase.Root;
}
public void Duplicates_Should_Not_Be_Inserted_Via_InsertRange()
{
var target = new Classes();
target.Add("foo");
target.InsertRange(1, new[] { "foo", "bar" });
Assert.Equal(new[] { "foo", "bar" }, target);
}
public void TestEnsureParseMethodStringCorrectly(
string methodString,
string expectedMethodName,
string expectedSignature)
{
CoverageResult result = new CoverageResult();
result.Identifier = Guid.NewGuid().ToString();
Lines lines = new Lines();
lines.Add(1, 1);
Branches branches = new Branches();
branches.Add(new BranchInfo {
Line = 1, Hits = 1, Offset = 23, EndOffset = 24, Path = 0, Ordinal = 1
});
Methods methods = new Methods();
methods.Add(methodString, new Method());
methods[methodString].Lines = lines;
methods[methodString].Branches = branches;
Classes classes = new Classes();
classes.Add("Google.Protobuf.Reflection.MessageDescriptor", methods);
Documents documents = new Documents();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
documents.Add(@"C:\doc.cs", classes);
}
else
{
documents.Add(@"/doc.cs", classes);
}
result.Modules = new Modules();
result.Modules.Add("module", documents);
CoberturaReporter reporter = new CoberturaReporter();
string report = reporter.Report(result);
Assert.NotEmpty(report);
var doc = XDocument.Load(new MemoryStream(Encoding.UTF8.GetBytes(report)));
var methodAttrs = doc.Descendants()
.Where(o => o.Name.LocalName == "method")
.Attributes()
.ToDictionary(o => o.Name.LocalName, o => o.Value);
Assert.Equal(expectedMethodName, methodAttrs["name"]);
Assert.Equal(expectedSignature, methodAttrs["signature"]);
}
public void AddDefaultLibraries()
{
var stringClass = new ClassModel("String", this, true);
stringClass.Methods.Add(new MethodModel("length", "Integer"));
var appendStringMethod = new MethodModel("append", "Integer");
appendStringMethod.Arguments.Add(new ArgumentModel("appendString", "String"));
var appendIntegerMethod = new MethodModel("append", "Integer");
appendIntegerMethod.Arguments.Add(new ArgumentModel("appendInteger", "Integer"));
stringClass.Methods.Add(appendIntegerMethod);
stringClass.Methods.Add(appendStringMethod);
stringClass.Methods.Add(new MethodModel("split", "String"));
stringClass.Methods.Add(new MethodModel("toInteger", "Integer"));
Classes.Add(stringClass);
Classes.Add(new ClassModel("Integer", this, true));
Classes.Add(new ClassModel("Any", this, true));
Classes.Add(new ClassModel("Bool", this, true));
Classes.Add(new ClassModel("Float", this, true));
Classes.Add(new ClassModel("Unit", this, true));
var fileReaderClass = new ClassModel("FileReader", this, true);
fileReaderClass.Fields.Add(new FieldModel("readerReference", "Integer"));
var openMethod = new MethodModel("open", BuiltinTypes.Unit);
openMethod.Arguments.Add(new ArgumentModel("s", "String"));
fileReaderClass.Methods.Add(openMethod);
fileReaderClass.Methods.Add(new MethodModel("readLine", "String"));
fileReaderClass.Methods.Add(new MethodModel("close", "Unit"));
Classes.Add(fileReaderClass);
var fileWriterClass = new ClassModel("FileWriter", this, true);
fileWriterClass.Fields.Add(new FieldModel("writerReference", "Integer"));
var openWriterMethod = new MethodModel("open", BuiltinTypes.Unit);
openWriterMethod.Arguments.Add(new ArgumentModel("s", "String"));
fileWriterClass.Methods.Add(openWriterMethod);
var writeLineMethod = new MethodModel("writeLine", BuiltinTypes.Unit);
writeLineMethod.Arguments.Add(new ArgumentModel("s", "String"));
fileWriterClass.Methods.Add(writeLineMethod);
fileWriterClass.Methods.Add(new MethodModel("close", "Unit"));
Classes.Add(fileWriterClass);
var arrayClass = new ClassModel("Array", this, true);
arrayClass.Methods.Add(new MethodModel("size", "Integer"));
Classes.Add(arrayClass);
}
public GeneratorEditor(GenDataBase genDataBase)
{
GenDataBase = genDataBase;
Classes.Add("GenSettings");
Classes.Add("FileGroup");
Classes.Add("BaseFile");
Classes.Add("Profile");
SubClasses.Add("GenSettings");
base.GenObject = genDataBase.Root;
}
private void AddClass(ScopeTypeEnum access, string s)
{
var cls = new Class(access, s, this);
if (HasClass(cls.Name))
{
throw new Exception(string.Format("Cannot Create Class {0} class already exists.", cls.Name));
}
Classes.Add(cls);
}
public BootstrapFormGroup()
{
Classes.Add("form-group");
Label = new BootstrapLabel();
Input = new BootstrapFormInput();
Children.Add(Label);
Children.Add(Input);
}
public static void TakeInitialClass(IPlayerClass playerClass)
{
FeaturesManager.RemoveClassFeatures();
ProficiencyManager.RemoveClassProficiencies();
PrimaryClass = playerClass.TakeAsPrimaryClass();
Classes.Clear();
Classes.Add(PrimaryClass);
HitDiceTotal = new CompoundDice(PrimaryClass.CurrentTotalHitDice);
HitDiceCurrent = new CompoundDice(HitDiceTotal);
}
public GuideBodyCellLeftGrayCountryFactory(string name, string value, string geoParent, string columnPosition)
: base(name, value)
{
Classes.Add("col-" + columnPosition);
Classes.Add("MKT_DEF_TD_COL bg-gray left-aligned white-text");
Attributes.Add("nowrap", "nowrap");
Geo = value;
GeoParent = geoParent;
}
public void Listeners_Can_Be_Removed_By_Listener()
{
var classes = new Classes();
var listener1 = new ClassesChangedListener(() => { });
var listener2 = new ClassesChangedListener(() => classes.RemoveListener(listener1));
classes.AddListener(listener1);
classes.AddListener(listener2);
classes.Add("bar");
}
private void OnCharacterCreationDataPacket(PacketBase p)
{
var packet = (CharacterCreationDataPacket)p;
Classes.Clear();
foreach (var @class in packet.Classes)
{
Classes.Add(@class);
}
}
public void calc_class_list()
{
if (Classes == null)
{
Classes = new List <string>();
}
foreach (DataRow datarow in Dataset.Rows)
{
Classes.Add(Convert.ToString(datarow[Number_of_features - 1]));
}
}
public TestClassViewModel Class(Type type)
{
var c = Classes.SingleOrDefault(x => x.Name == type.Name);
if (c == null)
{
c = new TestClassViewModel(type);
Classes.Add(c);
}
return(c);
}
private void CreateDocumentFromJToken(JProperty documentToken)
{
foreach (JObject classObject in documentToken.Children())
{
foreach (JProperty classProperty in classObject.Children())
{
string className = Path.GetFileName(classProperty.Name);
Classes.Add(new Class(className, classProperty));
}
}
}
public ArcImsLegendGroup(TocGroup tocGroup)
{
_tocGroup = tocGroup;
Heading = _tocGroup.Heading;
foreach (TocClass tocClass in tocGroup)
{
Classes.Add(new ArcImsLegendClass(tocClass));
}
}
public StudentsViewModel()
{
ViewSource = new CollectionViewSource();
ViewSource.Source = ClassStudents;
Classes = StationManager.DataStorage.GetClasses(CurrentYear);
Class temp = new Class();
temp.NumberLetter = "Все";
Classes.Add(temp);
ViewSource.Filter += new FilterEventHandler(ShowWithFilter);
}
public void AddClass(ClassDeclarationSyntax syntax)
{
string className = syntax.Identifier.Text;
if (Classes.ContainsKey(className))
{
throw new ArgumentException($"Class: {className} already exist.");
}
Classes.Add(className, syntax);
}
public TypeStamp(Type type, bool withTransient = false) : this()
{
var structure = StampHelpers.GetFieldsStructureInSerializationOrder(type, withTransient);
ModuleGUID = type.Module.ModuleVersionId;
foreach (var cl in structure)
{
Classes.Add(new TypeDescriptor(cl));
}
}
public async Task <bool> add(Class _class)
{
// Perform the save operation on the database,
// and update the model with the newly created ID.
_class.Id = await _databaseService.SaveClass(_class);
Classes.Add(_class);
OnPropertyChanged("Classes");
return(true);
}
public Class(string id, string name, string colorCode, string format, string scheduleFormat)
{
this.Id = id;
this.Name = name;
this.Format = format;
this.ScheduleFormat = scheduleFormat;
this.Color = new SolidColorBrush((Color)ColorConverter.ConvertFromString(colorCode));
Classes.Add(this);
}
public AgsLegendGroup(MapServerLegendGroup mapServerLegendGroup)
{
_mapServerLegendGroup = mapServerLegendGroup;
Heading = mapServerLegendGroup.Heading;
foreach (MapServerLegendClass mapServerLegendClass in mapServerLegendGroup.LegendClasses)
{
Classes.Add(new AgsLegendClass(mapServerLegendClass));
}
}
public PhpClassDefinition FindOrCreateClass(PhpQualifiedName phpClassName, PhpQualifiedName baseClass)
{
var c = Classes.FirstOrDefault(i => phpClassName == i.Name);
if (c != null)
{
return(c);
}
c = new PhpClassDefinition(phpClassName, baseClass);
Classes.Add(c);
return(c);
}
public void ReadFrom(PrimitiveReader reader)
{
ModuleGUID = reader.ReadGuid();
var classNo = reader.ReadInt32();
for (var j = 0; j < classNo; j++)
{
var td = new TypeDescriptor();
td.ReadFrom(reader);
Classes.Add(td);
}
}
private void SetImage(string imagePath)
{
Classes.Add("image");
Children.Remove(DivImg);
DivImg = new HtmlControlBase(Page)
{
HtmlDefaultTag = "img",
};
DivImg.Attributes["src"] = imagePath;
Children.Insert(0, DivImg);
}
public Class AddNewClass(string className)
{
if (ClassExist(className))
{
return(Classes.FirstOrDefault(c => c.Name == className));
}
Class newClass = new Class(className);
Classes.Add(newClass);
return(newClass);
}
/// <summary>
/// Adds a CSS class.
/// </summary>
/// <param name="name">The css class name.</param>
public void AddClass(string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (Classes == null)
{
Classes = new List <string>(2); // Use half list compare to default capacity (4), as we don't expect lots of classes
}
Classes.Add(name);
}
public void TakeAllRouts()
{
Classes.Clear();
Classes.Add(new FlightsModel {
clas = "Бизнес"
});
Classes.Add(new FlightsModel {
clas = "Эконом"
});
Routs.Clear();
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.CommandText = @"select id_route,s1.town,s2.town,length_of_route from route inner join airport s1 on s1.nameAirport = route.id_airport_from
inner join airport s2 on s2.nameAirport = route.id_airport_to";
sqlCommand.Connection = DBConnection.DBConnection.SqlConnection;
SqlDataReader reader = sqlCommand.ExecuteReader();
foreach (var i in reader)
{
Routs.Add(new RouteModel {
IdRoute = reader.GetInt32(0), airport_From_To = $"{reader.GetString(1)} - {reader.GetString(2)}", length_of_route = Convert.ToString(reader.GetInt32(3))
});
}
reader.Close();
Aircrafts.Clear();
sqlCommand.CommandText = @"select * from aircrafts";
sqlCommand.Connection = DBConnection.DBConnection.SqlConnection;
SqlDataReader reader2 = sqlCommand.ExecuteReader();
foreach (var i in reader2)
{
Aircrafts.Add(new AircraftModel {
name_aircraft = reader2.GetString(0), count_of_seats = reader2.GetInt32(1).ToString(), speed = reader2.GetInt32(2).ToString()
});
}
reader2.Close();
Company.Clear();
sqlCommand.CommandText = @"select * from company";
sqlCommand.Connection = DBConnection.DBConnection.SqlConnection;
SqlDataReader reader3 = sqlCommand.ExecuteReader();
foreach (var i in reader3)
{
Company.Add(new CompanyModel {
company_name = reader3.GetString(0), cost_of_1km = reader3.GetFloat(1).ToString(), cost_of_business = reader3.GetFloat(2).ToString(), cost_of_econom = reader3.GetFloat(3).ToString()
});
}
reader3.Close();
}
public BlockClassListViewModel(BlockClassManagement bussiness) : base()
{
_bussiness = bussiness;
if (_bussiness.BlockClassCollection != null)
{
_bussiness.BlockClassCollection.ForEach(c =>
{
Classes.Add(new ClassViewModel(c));
Classes.Last().ClassOperatedEvent += OnClassOperated;
});
}
_bussiness.BlockClassChangedEvent += OnBlockClassChanged;
}
public void Should_Not_Be_Able_To_Add_Pseudoclass()
{
var target = new Classes();
Assert.Throws<ArgumentException>(() => target.Add(":foo"));
}
