public void CounterInitialisationDefault() { //// Arrange PlayerPrefs.DeleteAll(); //// Act var counterConfiguration = new CounterConfiguration() { SaveBest = CounterConfiguration.SaveType.None }; var counter = new Counter(counterConfiguration); //// Assert Assert.AreEqual(counterConfiguration, counter.Configuration, "Counter configuration not initialised correctly"); Assert.AreEqual(-1, counter.Identifier, "Identifier configuration not initialised correctly"); Assert.AreEqual(0, counter.IntAmount, "IntAmount not initialised correctly"); Assert.AreEqual(0, counter.IntAmountSaved, "IntAmountLastSaved not initialised correctly"); Assert.AreEqual(0, counter.IntAmountBest, "IntAmountBest not initialised correctly"); Assert.AreEqual(0, counter.IntAmountBestSaved, "IntAmountBestLastSaved not initialised correctly"); Assert.AreEqual(0, counter.FloatAmount, "FloatAmount not initialised correctly"); Assert.AreEqual(0, counter.FloatAmountSaved, "FloatAmountLastSaved not initialised correctly"); Assert.AreEqual(0, counter.FloatAmountBest, "FloatAmountBest not initialised correctly"); Assert.AreEqual(0, counter.FloatAmountBestSaved, "FloatAmountBestLastSaved not initialised correctly"); Assert.AreEqual(CounterConfiguration.CounterTypeEnum.Int, counter.Configuration.CounterType, "Configuration.CounterType not initialised correctly"); Assert.AreEqual(0, counter.Configuration.IntMinimum, "Configuration.IntMinimum not initialised correctly"); Assert.AreEqual(int.MaxValue, counter.Configuration.IntMaximum, "Configuration.IntMaximum not initialised correctly"); Assert.AreEqual(0, counter.Configuration.FloatMinimum, "Configuration.FloatMinimum not initialised correctly"); Assert.AreEqual(float.MaxValue, counter.Configuration.FloatMaximum, "Configuration.FloatMaximum not initialised correctly"); Assert.AreEqual(CounterConfiguration.SaveType.None, counter.Configuration.Save, "Configuration.PersistChanges not initialised correctly"); }
public void BoundariesStrongTest() { string counterName = "strongTestBoundaries"; int initialValue = 1; var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(initialValue, 0, 20, 0, CounterType.BOUNDED_STRONG, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetStrongCounter(counterName); Assert.AreEqual(1, counter.GetValue()); Assert.Throws <Infinispan.HotRod.Exceptions.CounterLowerBoundException>(() => { counter.AddAndGet(-10); }); Assert.Throws <Infinispan.HotRod.Exceptions.CounterUpperBoundException>(() => { counter.AddAndGet(30); }); Assert.Throws <Infinispan.HotRod.Exceptions.CounterLowerBoundException>(() => { counter.CompareAndSet(20, -1); }); Assert.Throws <Infinispan.HotRod.Exceptions.CounterUpperBoundException>(() => { counter.CompareAndSet(20, 21); }); Assert.Throws <Infinispan.HotRod.Exceptions.CounterLowerBoundException>(() => { counter.CompareAndSwap(20, -1); }); Assert.Throws <Infinispan.HotRod.Exceptions.CounterUpperBoundException>(() => { counter.CompareAndSwap(20, 21); }); rcm.Remove(counterName); }
public void ConfigurationWeakTest() { string counterName = "weakTestConfiguration"; var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(0, 0, 0, 64, CounterType.WEAK, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetWeakCounter(counterName); ICounterConfiguration retCc = counter.GetConfiguration(); Assert.AreEqual(cc.GetConcurrencyLevel(), retCc.GetConcurrencyLevel()); Assert.AreEqual(cc.GetType(), retCc.GetType()); Assert.AreEqual(cc.GetStorage(), retCc.GetStorage()); Assert.AreEqual(counter.GetName(), counterName); rcm.Remove(counterName); string counterName1 = "weakTestConfiguration1"; var cc1 = new CounterConfiguration(0, 0, 0, 1, CounterType.WEAK, Storage.PERSISTENT); rcm.DefineCounter(counterName1, cc1); counter = rcm.GetWeakCounter(counterName1); ICounterConfiguration retCc1 = counter.GetConfiguration(); Assert.AreEqual(cc1.GetConcurrencyLevel(), retCc1.GetConcurrencyLevel()); Assert.AreEqual(cc1.GetType(), retCc1.GetType()); Assert.AreEqual(cc1.GetStorage(), retCc1.GetStorage()); Assert.AreEqual(counter.GetName(), counterName1); rcm.Remove(counterName1); }
public void CounterPersistentValuesSavedInt(string prefsPrefix, string counterName, int amount, int bestAmount) { //// Arrange PlayerPrefs.DeleteAll(); var counterConfiguration = new CounterConfiguration() { Name = counterName, Save = CounterConfiguration.SaveType.Always, CounterType = CounterConfiguration.CounterTypeEnum.Int }; var counter = new Counter(counterConfiguration, prefsPrefix); counter.IntAmount = bestAmount; // to set best counter.IntAmount = amount; //// Act counter.UpdatePlayerPrefs(); PlayerPrefs.Save(); //// Assert Assert.AreEqual(amount, PlayerPrefs.GetInt(string.Format("{0}CI.{1}", prefsPrefix, counterName), 0), "IntAmount not saved correctly"); Assert.AreEqual(bestAmount, PlayerPrefs.GetInt(string.Format("{0}CIH.{1}", prefsPrefix, counterName), 0), "HighestIntAmount not saved correctly"); }
public void CounterNonPersistentValuesNotSavedFloat(string prefsPrefix, string counterName, float amount, float bestAmount) { //// Arrange PlayerPrefs.DeleteAll(); var counterConfiguration = new CounterConfiguration() { Name = counterName, SaveBest = CounterConfiguration.SaveType.None, // Save defaults to none CounterType = CounterConfiguration.CounterTypeEnum.Float }; var counter = new Counter(counterConfiguration, prefsPrefix); counter.FloatAmount = amount; //counter.FloatAmountBest = bestAmount; //// Act counter.UpdatePlayerPrefs(); PlayerPrefs.Save(); //// Assert Assert.IsFalse(PlayerPrefs.HasKey(string.Format("{0}CI.{1}", prefsPrefix, counterName)), "FloatAmount should not have been saved"); Assert.IsFalse(PlayerPrefs.HasKey(string.Format("{0}CIH.{1}", prefsPrefix, counterName)), "HighestFloatAmount should not have been saved"); }
public void AddRemoveCounterWithListenerWeakTest() { Semaphore s = new Semaphore(0, 1); Action <Event.CounterEvent> a = (Event.CounterEvent e) => { s.Release(); }; string counterName = "weak1TestAddRemoveListener"; Event.CounterListener cl = new Event.CounterListener(counterName, a); var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(5, 0, 20, 8, CounterType.WEAK, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetWeakCounter(counterName); object o = counter.AddListener(cl); counter.Add(10); Assert.True(s.WaitOne(5000)); counter.Remove(); // After the remove no events should arrive changeCounterFromAnotherCacheManager(); Assert.False(s.WaitOne(5000)); // if the counter is recreated, events should come again var counter1 = rcm.GetWeakCounter(counterName); counter1.Add(10); Assert.AreEqual(15, counter1.GetValue()); Assert.True(s.WaitOne(5000)); counter.RemoveListener(o); }
public void ConfigurationStrongTest() { string counterName = "strongTestConfiguration"; var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(0, -256, 65536, 64, CounterType.BOUNDED_STRONG, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetStrongCounter(counterName); ICounterConfiguration retCc = counter.GetConfiguration(); Assert.AreEqual(cc.GetLowerBound(), retCc.GetLowerBound()); Assert.AreEqual(cc.GetUpperBound(), retCc.GetUpperBound()); Assert.AreEqual(0, retCc.GetConcurrencyLevel()); Assert.AreEqual(cc.GetType(), retCc.GetType()); Assert.AreEqual(cc.GetStorage(), retCc.GetStorage()); Assert.AreEqual(counter.GetName(), counterName); rcm.Remove(counterName); string counterName1 = "strongTestConfiguration1"; var cc1 = new CounterConfiguration(0, -100, 100, 1, CounterType.UNBOUNDED_STRONG, Storage.PERSISTENT); rcm.DefineCounter(counterName1, cc1); counter = rcm.GetStrongCounter(counterName1); ICounterConfiguration retCc1 = counter.GetConfiguration(); Assert.AreEqual(0, retCc1.GetLowerBound()); Assert.AreEqual(0, retCc1.GetUpperBound()); Assert.AreEqual(0, retCc1.GetConcurrencyLevel()); Assert.AreEqual(cc1.GetType(), retCc1.GetType()); Assert.AreEqual(cc1.GetStorage(), retCc1.GetStorage()); Assert.AreEqual(counter.GetName(), counterName1); rcm.Remove(counterName1); }
public override void OnInspectorGUI() { serializedObject.Update(); ShowHeaderGUI(); EditorGUILayout.PropertyField(_gameItemTypeProperty); EditorGUILayout.PropertyField(_contextProperty); var counterConfiguration = GameConfiguration.Instance.GetCounterConfiguration((GameConfiguration.GameItemType)_gameItemTypeProperty.enumValueIndex); string[] _counters = new string[counterConfiguration.Count]; _counterIndex = 0; // initialise incase gameitem type changed for (int i = 0; i < counterConfiguration.Count; i++) { _counters[i] = counterConfiguration[i].Name; if (_counters[i] == _counterProperty.stringValue) { _counterIndex = i; } } int newIndex = EditorGUILayout.Popup("Counter", _counterIndex, _counters); if (newIndex != _counterIndex || string.IsNullOrEmpty(_counterProperty.stringValue)) { _counterProperty.stringValue = _counters[newIndex]; _counterIndex = newIndex; } CounterConfiguration = counterConfiguration[_counterIndex]; ShowFooterGUI(); serializedObject.ApplyModifiedProperties(); }
public Counter CreateCounter(string name, string help, CounterConfiguration configuration) { configuration = configuration ?? CounterConfiguration.Default; var metric = new Counter(name, help, configuration.LabelNames, configuration.SuppressInitialValue); return((Counter)_registry.GetOrAdd(metric)); }
public void AddRemoveListenerWeakTest() { Semaphore s = new Semaphore(0, 1); bool secondEvent = false; Action <Event.CounterEvent> a = (Event.CounterEvent e) => { if (!secondEvent) { Assert.AreEqual(5, e.OldValue); Assert.AreEqual(15, e.NewValue); Assert.AreEqual(Event.CounterState.VALID, e.NewState); Assert.AreEqual(Event.CounterState.VALID, e.OldState); secondEvent = true; } s.Release(); }; Action <Event.CounterEvent> a2 = (Event.CounterEvent e) => { Assert.AreEqual(6, e.OldValue); Assert.AreEqual(16, e.NewValue); Assert.AreEqual(Event.CounterState.VALID, e.NewState); Assert.AreEqual(Event.CounterState.VALID, e.OldState); s.Release(); }; string counterName = "weakTestAddRemoveListener"; Event.CounterListener cl = new Event.CounterListener(counterName, a); Event.CounterListener cl1 = new Event.CounterListener(counterName, a2); var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(5, 0, 20, 8, CounterType.WEAK, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetWeakCounter(counterName); object o = counter.AddListener(cl); counter.Add(10); Assert.True(s.WaitOne(5000)); counter.RemoveListener(o); counter.Add(-9); Assert.False(s.WaitOne(5000)); object o1 = counter.AddListener(cl1); counter.Add(10); Assert.True(s.WaitOne(5000)); counter.RemoveListener(o1); }
public void CompareAndSetStrongTest() { string counterName = "strongTestCompareAndSet"; int initialValue = 2; var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(initialValue, 0, 0, 0, CounterType.UNBOUNDED_STRONG, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetStrongCounter(counterName); Assert.False(counter.CompareAndSet(0, 1)); Assert.True(counter.CompareAndSet(2, 3)); Assert.True(counter.CompareAndSet(3, 4)); rcm.Remove(counterName); }
public void ResetStrongTest() { string counterName = "strongTestReset"; int initialValue = 5; var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(initialValue, 0, 200, 8, CounterType.BOUNDED_STRONG, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetStrongCounter(counterName); int val = counter.GetValue(); var name = counter.GetName(); Assert.AreEqual(initialValue, counter.GetValue()); rcm.Remove(counterName); }
public void CompareAndSwapStrongTest() { string counterName = "strongTestCompareAndSwap"; int initialValue = 3; var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(initialValue, 0, 0, 0, CounterType.UNBOUNDED_STRONG, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetStrongCounter(counterName); Assert.AreEqual(3, counter.CompareAndSwap(1, 2)); Assert.AreEqual(3, counter.CompareAndSwap(3, 2)); Assert.AreEqual(2, counter.CompareAndSwap(3, 4)); Assert.AreEqual(2, counter.CompareAndSwap(2, 5)); rcm.Remove(counterName); }
public void AddStrongTest() { string counterName = "strongTestAdd"; int initialValue = 10; var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(initialValue, 0, 0, 8, CounterType.UNBOUNDED_STRONG, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetStrongCounter(counterName); Assert.AreEqual(counter.GetValue(), 10); Assert.AreEqual(counter.AddAndGet(10), 20); Assert.AreEqual(counter.AddAndGet(-20), 0); Assert.AreEqual(counter.AddAndGet(-20), -20); rcm.Remove(counterName); }
public void ResetWeakTest() { string counterName = "weakTestReset"; int initialValue = 5; var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(initialValue, 0, 0, 8, CounterType.WEAK, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetWeakCounter(counterName); Assert.AreEqual(5, counter.GetValue()); counter.Add(100); Assert.AreEqual(105, counter.GetValue()); counter.Reset(); Assert.AreEqual(counter.GetValue(), initialValue); rcm.Remove(counterName); }
public StronglyTypedRavenSettings(NameValueCollection settings) { Replication = new ReplicationConfiguration(); Voron = new VoronConfiguration(); Esent = new EsentConfiguration(); Prefetcher = new PrefetcherConfiguration(); FileSystem = new FileSystemConfiguration(); Counter = new CounterConfiguration(); TimeSeries = new TimeSeriesConfiguration(); Encryption = new EncryptionConfiguration(); Indexing = new IndexingConfiguration(); WebSockets = new WebSocketsConfiguration(); Cluster = new ClusterConfiguration(); Monitoring = new MonitoringConfiguration(); Studio = new StudioConfiguration(); this.settings = settings; }
protected virtual ICollector <ICounter> CreateErrorTotalCounter() { string[] defaultLabels = new[] { "operation", "sli_error_type", "sli_dependency" }; var configuration = new CounterConfiguration { SuppressInitialValue = true, LabelNames = defaultLabels }; _options.ConfigureErrorTotalCounter?.Invoke(configuration); if (configuration.LabelNames != defaultLabels) { throw new ArgumentException("The error total counter configuration is missing the required default labels"); } return(_metrics.CreateCounter("http_server_errors_total", "The number of HTTP requests resulting in an error", configuration)); }
public void CounterSetFloatWithinBounds(float min, float max, float amount, float expected) { //// Arrange PlayerPrefs.DeleteAll(); var counterConfiguration = new CounterConfiguration() { Name = "Counter", CounterType = CounterConfiguration.CounterTypeEnum.Float, SaveBest = CounterConfiguration.SaveType.None, FloatMinimum = min, FloatMaximum = max }; var counter = new Counter(counterConfiguration); //// Act counter.Set(amount); //// Assert Assert.AreEqual(expected, counter.FloatAmount, "Amount not set correctly."); }
public void FloatAmountChangeHandlerCalled(int expectedMessages, int expectedBestMessages, float amount1, float amount2) { //// Arrange var counterConfiguration = new CounterConfiguration() { SaveBest = CounterConfiguration.SaveType.None }; var counterCallbackTestClass = new CounterCallbackTestClass(); var counter = new Counter(counterConfiguration, counterChangedCallbacks: counterCallbackTestClass); counter.Set(amount1); //// Act counter.Set(amount2); //// Assert Assert.AreEqual(expectedMessages, counterCallbackTestClass.FloatAmountChangedCounter, "Incorrect number of messages sent."); Assert.AreEqual(expectedBestMessages, counterCallbackTestClass.FloatAmountBestChangedCounter, "Incorrect number of messages sent."); Assert.AreEqual(amount1, counterCallbackTestClass.OldFloatAmount, "Incorrect old amount in message."); Assert.AreEqual(amount2, counterCallbackTestClass.NewFloatAmount, "Incorrect new amount in message."); }
/// <summary> /// This function can be overridden by inheriting classes, but if it isn't, draw the default for it's properties. /// </summary> protected override void DrawGUI() { EditorGUILayout.PropertyField(_gameItemTypeProperty); EditorGUILayout.PropertyField(_contextProperty); var counterConfiguration = GameConfiguration.Instance.GetCounterConfiguration((GameConfiguration.GameItemType)_gameItemTypeProperty.enumValueIndex); var counters = new string[counterConfiguration.Count]; _counterIndex = 0; // initialise incase gameitem type changed for (int i = 0; i < counterConfiguration.Count; i++) { counters[i] = counterConfiguration[i].Name; if (counters[i] == _counterProperty.stringValue) { _counterIndex = i; } } int newIndex = EditorGUILayout.Popup("Counter", _counterIndex, counters); if (newIndex != _counterIndex || string.IsNullOrEmpty(_counterProperty.stringValue)) { _counterProperty.stringValue = counters[newIndex]; _counterIndex = newIndex; } CounterConfiguration = counterConfiguration[_counterIndex]; EditorGUILayout.BeginHorizontal(); EditorGUILayout.PrefixLabel(new GUIContent("Amount", "The value to compare against")); EditorGUILayout.PropertyField(_comparisonProperty, GUIContent.none, GUILayout.ExpandWidth(true)); if (CounterConfiguration.CounterType == CounterConfiguration.CounterTypeEnum.Int) { EditorGUILayout.PropertyField(_intAmountProperty, GUIContent.none, GUILayout.ExpandWidth(true)); } else { EditorGUILayout.PropertyField(_floatAmountProperty, GUIContent.none, GUILayout.ExpandWidth(true)); } EditorGUILayout.EndHorizontal(); }
public void CounterInitialisationPersistentFloatValuesLoaded(string prefsPrefix, string counterName, float amount, float bestAmount) { //// Arrange PlayerPrefs.DeleteAll(); PlayerPrefs.SetFloat(string.Format("{0}CF.{1}", prefsPrefix, counterName), amount); PlayerPrefs.SetFloat(string.Format("{0}CFH.{1}", prefsPrefix, counterName), bestAmount); //// Act var counterConfiguration = new CounterConfiguration() { Name = counterName, Save = CounterConfiguration.SaveType.Always, CounterType = CounterConfiguration.CounterTypeEnum.Float }; var counter = new Counter(counterConfiguration, prefsPrefix); counter.LoadFromPrefs(); //// Assert Assert.AreEqual(amount, counter.FloatAmount, "FloatAmount not set correctly"); Assert.AreEqual(bestAmount, counter.FloatAmountBest, "HighestFloatAmount not set correctly"); }
public void CounterResetInt(int defaultAmount, int amount) { //// Arrange PlayerPrefs.DeleteAll(); var counterConfiguration = new CounterConfiguration() { Name = "Counter", CounterType = CounterConfiguration.CounterTypeEnum.Int, IntDefault = defaultAmount, SaveBest = CounterConfiguration.SaveType.None, }; var counter = new Counter(counterConfiguration); counter.Set(amount); //// Act counter.Reset(); //// Assert Assert.AreEqual(defaultAmount, counter.IntAmount, "Reset did not set default amount correctly."); }
/// <summary> /// Constructor to hold necessary references. /// </summary> /// <param name="counterConfigurationEntry"></param> /// <param name="prefsPrefix"></param> /// <param name="identifier"></param> /// <param name="counterChangedCallbacks"></param> public Counter(CounterConfiguration counterConfigurationEntry, string prefsPrefix = null, int identifier = -1, ICounterChangedCallback counterChangedCallbacks = null) { Assert.IsTrue(prefsPrefix != null || (counterConfigurationEntry.Save == CounterConfiguration.SaveType.None && counterConfigurationEntry.SaveBest == CounterConfiguration.SaveType.None), "If persisting a counter then ensure to pass a valid prefs prefix to use."); Configuration = counterConfigurationEntry; Identifier = identifier; if (counterConfigurationEntry.CounterType == CounterConfiguration.CounterTypeEnum.Int) { IntAmount = counterConfigurationEntry.IntDefault; } else { FloatAmount = counterConfigurationEntry.FloatDefault; } _prefsPrefix = prefsPrefix; _counterChangedCallbacks = counterChangedCallbacks; SetupPrefsKeys(); }
public void PushToSavedFloat(float amount, float amountBest, CounterConfiguration.SaveType save, CounterConfiguration.SaveType saveBest) { //// Arrange PlayerPrefs.DeleteAll(); var counterConfiguration = new CounterConfiguration() { Save = save, SaveBest = saveBest }; var counter = new Counter(counterConfiguration, "Prefix."); counter.FloatAmount = amount; //counter.FloatAmountBest = amountBest; //// Act counter.PushToSaved(); //// Assert if (save == CounterConfiguration.SaveType.None) { Assert.AreEqual(0, counter.FloatAmountSaved, "FloatAmount wrongly pushed to save."); } else { Assert.AreEqual(counter.FloatAmount, counter.FloatAmountSaved, "Amount not pushed to save."); } if (saveBest == CounterConfiguration.SaveType.None) { Assert.AreEqual(0, counter.FloatAmountBestSaved, "FloatAmountBest wrongly pushed to save."); } else { Assert.AreEqual(counter.FloatAmountBest, counter.FloatAmountBestSaved, "IntAmountBest not pushed to save."); } }
public RavenConfiguration() { Settings = new NameValueCollection(StringComparer.OrdinalIgnoreCase); Core = new CoreConfiguration(this); FileSystem = new FileSystemConfiguration(Core); Counter = new CounterConfiguration(Core); TimeSeries = new TimeSeriesConfiguration(Core); Replication = new ReplicationConfiguration(); Prefetcher = new PrefetcherConfiguration(); Storage = new StorageConfiguration(); Encryption = new EncryptionConfiguration(); Indexing = new IndexingConfiguration(); WebSockets = new WebSocketsConfiguration(); Cluster = new ClusterConfiguration(); Monitoring = new MonitoringConfiguration(); Queries = new QueryConfiguration(); Patching = new PatchingConfiguration(); BulkInsert = new BulkInsertConfiguration(); Server = new ServerConfiguration(); Memory = new MemoryConfiguration(); Expiration = new ExpirationBundleConfiguration(); Versioning = new VersioningBundleConfiguration(); Studio = new StudioConfiguration(); Tenants = new TenantConfiguration(); Licensing = new LicenseConfiguration(); Quotas = new QuotasBundleConfiguration(); IndexingClassifier = new DefaultIndexingClassifier(); Catalog = new AggregateCatalog(CurrentAssemblyCatalog); Catalog.Changed += (sender, args) => ResetContainer(); }
public void CounterInitialisationPersistentIntValuesLoaded(string prefsPrefix, string counterName, int amount, int bestAmount) { //// Arrange PlayerPrefs.DeleteAll(); PlayerPrefs.SetInt(string.Format("{0}CI.{1}", prefsPrefix, counterName), amount); PlayerPrefs.SetInt(string.Format("{0}CIH.{1}", prefsPrefix, counterName), bestAmount); //// Act var counterConfiguration = new CounterConfiguration() { Name = counterName, Save = CounterConfiguration.SaveType.Always, //SaveBest defaults to Always CounterType = CounterConfiguration.CounterTypeEnum.Int }; var counter = new Counter(counterConfiguration, prefsPrefix); counter.LoadFromPrefs(); //// Assert Assert.AreEqual(amount, counter.IntAmount, "IntAmount not set correctly"); Assert.AreEqual(amount, counter.IntAmountSaved, "IntAmountLastSaved not set correctly"); Assert.AreEqual(bestAmount, counter.IntAmountBest, "IntAmountBest not set correctly"); Assert.AreEqual(bestAmount, counter.IntAmountBestSaved, "IntAmountBestLastSaved not set correctly"); }
public void CounterInitialisationPersistentFloatValuesNotLoaded(string prefsPrefix, string counterName, float amount, float bestAmount) { //// Arrange PlayerPrefs.DeleteAll(); PlayerPrefs.SetFloat(string.Format("{0}CI.{1}", prefsPrefix, counterName), amount); PlayerPrefs.SetFloat(string.Format("{0}CIH.{1}", prefsPrefix, counterName), bestAmount); //// Act var counterConfiguration = new CounterConfiguration() { Name = counterName, SaveBest = CounterConfiguration.SaveType.None, //Save defaults to None CounterType = CounterConfiguration.CounterTypeEnum.Float }; var counter = new Counter(counterConfiguration, prefsPrefix); counter.LoadFromPrefs(); //// Assert Assert.AreEqual(0, counter.FloatAmount, "FloatAmount not set correctly"); Assert.AreEqual(0, counter.FloatAmountSaved, "FloatAmountSaved not set correctly"); Assert.AreEqual(0, counter.FloatAmountBest, "FloatAmountBest not set correctly"); Assert.AreEqual(0, counter.FloatAmountBestSaved, "FloatAmountBestSaved not set correctly"); }
/// <summary> /// Counters only increase in value and reset to zero when the process restarts. /// </summary> public static Counter CreateCounter(string name, string help, CounterConfiguration configuration = null) => _defaultFactory.CreateCounter(name, help, configuration);
public void BasicListenerStrongTest() { int step = 0; Semaphore s = new Semaphore(0, 1); Action <Event.CounterEvent> a2 = (Event.CounterEvent e) => { switch (step) { case 0: Assert.AreEqual(5, e.OldValue); Assert.AreEqual(15, e.NewValue); Assert.AreEqual(Event.CounterState.VALID, e.NewState); Assert.AreEqual(Event.CounterState.VALID, e.OldState); s.Release(); break; case 1: Assert.AreEqual(15, e.OldValue); Assert.AreEqual(0, e.NewValue); Assert.AreEqual(Event.CounterState.LOWER_BOUND_REACHED, e.NewState); Assert.AreEqual(Event.CounterState.VALID, e.OldState); s.Release(); break; case 2: Assert.AreEqual(0, e.OldValue); Assert.AreEqual(20, e.NewValue); Assert.AreEqual(Event.CounterState.UPPER_BOUND_REACHED, e.NewState); Assert.AreEqual(Event.CounterState.LOWER_BOUND_REACHED, e.OldState); s.Release(); break; default: Assert.Fail(); break; } }; string counterName = "strongTestBasicListener"; Event.CounterListener cl = new Event.CounterListener(counterName, a2); var rcm = remoteManager.GetCounterManager(); var cc = new CounterConfiguration(5, 0, 20, 8, CounterType.BOUNDED_STRONG, Storage.VOLATILE); rcm.DefineCounter(counterName, cc); var counter = rcm.GetStrongCounter(counterName); object o = counter.AddListener(cl); counter.AddAndGet(10); Assert.True(s.WaitOne(15000)); step = 1; try { counter.AddAndGet(-20); } catch (CounterLowerBoundException) { } Assert.True(s.WaitOne(15000)); step = 2; try { counter.AddAndGet(30); } catch (CounterUpperBoundException) { } Assert.True(s.WaitOne(15000)); counter.RemoveListener(o); }
public Counter GetOrAddCounter(string name, string description, CounterConfiguration config = null) { return(Counters.GetOrAdd(name, Prometheus.Metrics.CreateCounter(name, description, config))); }