public void TestStartNumberSettingErrorFormat()
{
Dispenser dispenser = FormatParser.Parse(_testSerailNumberFormatString);
var expectedSerialNumber = "TEST20180517-Y39";
dispenser.SetStartNumber(expectedSerialNumber);
}
//==============================================//
public static void Main(string[] args)
{
strm = new StreamReader(new FileStream("SetMatrixAndExpression.txt", FileMode.Open, FileAccess.Read));
try
{
Read_matrices();
Array.Resize(ref mtx_mas, mtx_mas.Length - 1);
}
catch (ReadMatrixException)
{
Console.WriteLine("Ошибка ввода матриц!");
return;
}
string input = strm.ReadLine();
try
{
Console.WriteLine(Dispenser.Solver(mtx_mas, input));
}
catch (MatrixOperationExeption)
{
Console.WriteLine("Невыполнимая операция!");
}
}
public void AddDispenserTile()
{
int idx = -1;
for (int i = 0; i < tiles.Length; i++)
{
if (tiles[i] == null || tiles[i].transform.parent != tileRoot)
{
idx = i;
}
}
if (idx == -1)
{
idx = Random.Range(0, 4);
}
if (tiles[idx] != null && tiles[idx].transform.parent == tileRoot)
{
Destroy(tiles[idx].gameObject);
}
Dispenser newTile = Instantiate(dispenserPrefab);
newTile.name = "Dispenser" + ((int)Random.Range(0.0f, 128.0f));
newTile.transform.parent = tileRoot;
newTile.transform.position = new Vector3(13.0f, 0, 10.0f + 3.0f * idx);
tiles[idx] = newTile;
}
public void AddDispenserToInventoryAsync(Dispenser dispenser)
{
if (dispenser == null)
{
throw new ArgumentNullException();
}
}
public void ShouldListEventsFromThisWeek()
{
Events newEvents = new Events
{
{ new Event("2015/01/01", "one", "test") },
{ new Event(DateTime.Today.ToShortDateString(), "two") },
};
List <Event> expectedList = new List <Event>
{
{ new Event(DateTime.Today.ToShortDateString(), "two") },
};
string[] args = { "/search", "date", "this week" };
SearchDateArgument searchArgs = new SearchDateArgument(args);
string field = "";
string op = "";
string val1 = "";
string val2 = "";
searchArgs.IsValid();
field = searchArgs.Field;
op = searchArgs.Criteria;
val1 = searchArgs.Date;
val2 = searchArgs.AnotherDate;
string[] values = { val1, val2 };
Events filteredList = Dispenser.SearchEvents(newEvents, field, op, values);
Utils.AssertAreEqual(filteredList, expectedList);
}
public void DispenseTest()
{
Dispenser dispenser = new Dispenser();
VendingMachine vendingMachine = VendingMachine.Instance;
ContainableItem containableItem = Helpers.ContainableItem;
int initialQuantity = containableItem.Product.Quantity;
int id = containableItem.Position.Id;
vendingMachine.Items.Add(containableItem);
ContainableItem vendingMachineItem = vendingMachine.Items.FirstOrDefault(item => item.Position.Id == id);
Assert.ThrowsException <ProductNotFoundException>(() => dispenser.Dispense(23));
Assert.IsNotNull(dispenser.Dispense(id));
dispenser.Dispense(id);
Assert.AreNotEqual(initialQuantity, vendingMachine.Items.FirstOrDefault(item => item.Position.Id == id).Product.Quantity);
vendingMachineItem.Product.Quantity = 0;
Assert.ThrowsException <ProductNotFoundException>(() => dispenser.Dispense(id));
vendingMachineItem.Product.Quantity++;
vendingMachineItem.Product = null;
Assert.ThrowsException <ProductNotFoundException>(() => dispenser.Dispense(id));
}
// проверяем, является ли клапан четвертым в коллекторе - он всегда вода
public bool IsFourthValve()
{
string fourthValve = DispenserSuffix.Collector + "4";
int index = Dispenser != null?Dispenser.IndexOf(fourthValve) : -1;
return(index != -1);
}
public void ShouldListEventsWithEmptyDescription()
{
Events newEvents = new Events {
{ new Event("2015/01/01", "one", "test") },
{ new Event("2015/11/15", "two") },
};
List <Event> expectedList = new List <Event>
{
{ new Event("2015/11/15", "two") },
};
string[] inputArgs = { "/search", "title", "" };
SearchDescriptionArgument searchArgs = new SearchDescriptionArgument(inputArgs);
string field = "";
string op = "";
string val1 = "";
searchArgs.IsValid();
field = searchArgs.Field;
op = searchArgs.Criteria;
val1 = searchArgs.Value;
Events filteredList = Dispenser.SearchEvents(newEvents, field, op, new String[] { val1 });
Utils.AssertAreEqual(filteredList, expectedList);
}
public async Task PurchaseDispenserAsync(Dispenser dispenser)
{
if (dispenser == null)
{
throw new ArgumentNullException();
}
}
public override object Clone()
{
Dispenser aClone = (Dispenser)MemberwiseClone();
aClone.badguy = new List <string>(aClone.badguy);
return(aClone);
}
private static Dispenser GetATMDispenserBug()
{
var bill50Dispenser = new Dispenser(new Bill(50));
var bill20Dispenser = new Dispenser(new Bill(20));
bill50Dispenser.SetNext(bill20Dispenser);
return(bill50Dispenser);
}
public TypeInfoCachedData(RuntimeTypeInfo runtimeTypeInfo)
{
_runtimeTypeInfo = runtimeTypeInfo;
_methodLookupDispenser = new DispenserThatAlwaysReuses<String, RuntimeMethodInfo>(LookupDeclaredMethodByName);
_fieldLookupDispenser = new DispenserThatAlwaysReuses<String, RuntimeFieldInfo>(LookupDeclaredFieldByName);
_propertyLookupDispenser = new DispenserThatAlwaysReuses<String, RuntimePropertyInfo>(LookupDeclaredPropertyByName);
_eventLookupDispenser = new DispenserThatAlwaysReuses<String, RuntimeEventInfo>(LookupDeclaredEventByName);
}
public void DispenserToRegularTest()
{
Dispenser dispenser = FormatParser.Parse(_testSerailNumberFormatString);
var expectedPattern = @"TEST20180517-[甲乙丙][A-Z]\d\d";
var regex = dispenser.ToRegularExpression();
var target = regex.ToString();
Assert.AreEqual(expectedPattern, target);
}
public void DeleteDispenser(Dispenser dispenser)
{
if (dispenser == null)
{
throw new ArgumentNullException(nameof(dispenser));
}
_context.Dispensers.Remove(dispenser);
}
public async Task <Guid> AddAsync(Dispenser dispenser, CancellationToken cancellationToken = default)
{
await toolShedContext.DispenserSet
.AddAsync(dispenser);
await toolShedContext.SaveChangesAsync(cancellationToken);
return(dispenser.DispenserId);
}
/// <summary>
/// 取得符合抽號機的正規表示式
/// </summary>
/// <param name="dispenser"></param>
/// <returns></returns>
public static Regex ToRegularExpression(this Dispenser dispenser)
{
if (dispenser is null)
{
throw new ArgumentNullException(nameof(dispenser), $"{nameof(dispenser)} cannott be null");
}
var pattern = string.Join("", dispenser.SymbolDisks.Select(disk => disk.ToRegularFragmentString()));
return(new Regex(pattern));
}
public void FillTest()
{
//arrange
Dispenser d = new Dispenser();
//act
d.Fill(GumColor.Blue);
Assert.IsTrue(d.GumList.Count > 0);
}
private void linkLabel_ExportToHTML_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
string path = "";
if (saveFileDialogHTML.ShowDialog() == DialogResult.OK)
{
path = saveFileDialogHTML.FileName;
Dispenser.ExportToHTMLFile(path, displayedList);
}
}
public static Models.Repository.Dispenser ConvertDispenserToDtoDispenser(this Dispenser dispenser)
{
return(new Models.Repository.Dispenser
{
CreationDate = dispenser.CreationDate,
DecommissionDate = dispenser.DecommishDate,
DispenserName = dispenser.DispenserName,
LastMaintenanceCheckDate = dispenser.LastMaintenanceCheckDate
});
}
public void AddDispenser(Dispenser dispenser)
{
if (dispenser == null)
{
throw new ArgumentNullException(nameof(dispenser));
}
dispenser.Id = Guid.NewGuid();
_context.Dispensers.Add(dispenser);
}
private void InitDependencies()
{
this.itemsCollection = new ContainableItemsCollection(this);
this.itemsCollection.LoadFromFile(DatabaseFilePath);
this.statisticsComponent = new StatisticsComponent(this);
this.dispenser = new Dispenser(this);
this.dispenser.AddObserver(this.statisticsComponent);
this.dispenser.AddObserver(this.itemsCollection);
this.paymentTerminal = new PaymentTerminal();
this.paymentTerminal.AddObserver(this.dispenser);
}
public void AddDispenser(Guid dispenserId, Dispenser dispenser)
{
if (dispenser == null)
{
throw new ArgumentNullException(nameof(dispenser));
}
dispenser.Id = dispenserId;
_context.Dispensers.Add(dispenser);
}
public MvBinder(MvbBase vmInstance)
{
this._vmInstance = vmInstance;
this._runDictionary = new Dictionary <string, ICollection <Tuple <WeakReference, Action> > >();
this._runCollectionDictionary = new Dictionary <string, ICollection <Tuple <WeakReference, Action <MvbCollectionUpdateArgs> > > >();
//On UiThread Runner
this._uiRunner = Dispenser.GetRunner();
//Active listener on VM
this.ActiveListener();
}
private static Dispenser GetATMDispenser()
{
//var bill100Dispenser = new Dispenser(new Bill(100));
var bill50Dispenser = new Dispenser(new Bill(50));
var bill20Dispenser = new Dispenser(new Bill(20));
var bill10Dispenser = new Dispenser(new Bill(10));
//bill100Dispenser.SetNext(bill50Dispenser);
bill50Dispenser.SetNext(bill20Dispenser);
bill20Dispenser.SetNext(bill10Dispenser);
return(bill50Dispenser);
}
public void InitializeConstructors()
{
twixBand = new ProductBand();
paymentTerminal = new PaymentTerminal();
dispenser = new Dispenser();
twixItem = ProductFactory.CreateTwixProduct();
twixBand.Add(twixItem);
ProductBand.Instance().Add(twixItem);
paymentTerminal.Attach(dispenser);
}
public DispenserMovePattern(Vector3 centerPos, float radius, float speed, Dispenser tile)
{
this.radius = radius;
this.speed = speed;
this.centerPos = centerPos;
startPos = centerPos + radius * new Vector3(0, 0, 1);
left = new StraightMovement(BaseTile.eDirection.left, centerPos, Game.BOARD.GetTileLengths().x / 2.0f, 0.6f);
down = new StraightMovement(BaseTile.eDirection.down, centerPos, Game.BOARD.GetTileLengths().x / 2.0f, 0.6f);
right = new StraightMovement(BaseTile.eDirection.right, centerPos, Game.BOARD.GetTileLengths().x / 2.0f, 0.6f);
this.tile = tile;
}
public void ShouldNotListEventsFromSpecifiedDate()
{
Events newEvents = new Events {
{ new Event("2015/01/01", "one", "test") },
{ new Event("2015/11/15", "two") },
};
string[] inputArgs = { "/search", "date", "=", "2015/10/01" };
Events filteredList = Dispenser.GetFilteredListByDate(newEvents, "=", "2015/10/01", "");
filteredList.ShouldBeEmpty();
}
public void TestStartNumberSetting()
{
Dispenser dispenser = FormatParser.Parse(_testSerailNumberFormatString);
var expectedSerialNumber = "TEST20180517-乙Y39";
dispenser.SetStartNumber(expectedSerialNumber);
var startSerialNumber = dispenser.First();
Assert.AreEqual(expectedSerialNumber, startSerialNumber);
var sencondSerialNumber = dispenser.Skip(1).First();
Assert.AreEqual("TEST20180517-乙Y40", sencondSerialNumber);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Dispenser = await _context.Dispenser.FirstOrDefaultAsync(m => m.DispenserId == id);
if (Dispenser == null)
{
return(NotFound());
}
return(Page());
}
public void ShouldListOlderEventsFromSpecifiedDate()
{
Events newEvents = new Events {
{ new Event("2015/01/01", "one", "test") },
{ new Event("2015/11/15", "two") },
};
List <Event> expectedList = new List <Event>
{
{ new Event("2015/01/01", "one", "test") },
};
Events filteredList = Dispenser.GetFilteredListByDate(newEvents, "older", "2015/09/01", "");
Utils.AssertAreEqual(filteredList, expectedList);
}
public void ShouldListEventsFromSpecifiedPeriod()
{
Events newEvents = new Events {
{ new Event("2015/10/11", "one", "test") },
{ new Event(DateTime.Now.ToShortDateString(), "today", "today test") }
};
List <Event> expectedList = new List <Event> {
{ new Event("2015/10/11", "one", "test") }
};
Events filteredList = Dispenser.GetFilteredListByDate(newEvents, "<>", "2015/09/01", "2015/10/30");
Utils.AssertAreEqual(filteredList, expectedList);
}
void Start()
{
_fsm = new StateMachine<SlotMachineAI>(this);
_fsm.setState(new InsertCoinState());
wheelsArray[0] = GameObject.Find("Wheel0").GetComponent<Wheel>();
wheelsArray[1] = GameObject.Find("Wheel1").GetComponent<Wheel>();
wheelsArray[2] = GameObject.Find("Wheel2").GetComponent<Wheel>();
buttonsArray[0] = GameObject.Find("Button0").GetComponent<Button>();
buttonsArray[1] = GameObject.Find("Button1").GetComponent<Button>();
buttonsArray[2] = GameObject.Find("Button2").GetComponent<Button>();
lever = GameObject.Find("Lever").GetComponent<Lever>();
mouth = GameObject.Find("CatMouth").GetComponent<CatMouth>();
cookieDispenser = GameObject.Find("CookieDispenser").GetComponent<Dispenser>();
particles = GameObject.Find("Particles").GetComponent<ParticleSystem>();
}
public PackVendor()
{
packDispenser = new Dispenser();
}
