public void ClonedStructShouldBeIdentical()
{
var original = new CustomHeadsetEffect(Color.Red);
var clone = original.Clone();
Assert.That(clone, Is.EqualTo(original));
}
public void ShouldSetCorrectColor()
{
var effect = CustomHeadsetEffect.Create();
effect[3] = Color.Blue;
Assert.That(effect[3], Is.EqualTo(Color.Blue));
}
public void ShouldSetAllColorsWithColorConstructor()
{
var effect = new CustomHeadsetEffect(Color.Red);
for (var i = 0; i < HeadsetConstants.MaxLeds; i++)
{
Assert.That(effect[i], Is.EqualTo(Color.Red));
}
}
public void ClonedStructShouldBeIndependent()
{
var original = new CustomHeadsetEffect(Color.Red);
var clone = original.Clone();
clone.Set(Color.Blue);
Assert.That(clone, Is.Not.EqualTo(original));
}
public void ShouldSetBlackColorsWithCreate()
{
var effect = CustomHeadsetEffect.Create();
for (var i = 0; i < HeadsetConstants.MaxLeds; i++)
{
Assert.That(effect[i], Is.EqualTo(Color.Black));
}
}
public static CustomHeadsetEffect Combine(this CustomHeadsetEffect headset, Color c, double cPct = 0.5)
{
for (var i = 0; i < HeadsetConstants.MaxLeds; i++)
{
headset[i] = headset[i].Combine(c, cPct);
}
return(headset);
}
public void ShouldHaveCorrectColorsInProperty()
{
var colors = new Color[HeadsetConstants.MaxLeds];
colors[0] = Color.Red;
var effect = new CustomHeadsetEffect(colors.ToList());
Assert.AreEqual(colors, effect.Colors);
}
public static CustomHeadsetEffect Max(this CustomHeadsetEffect headset, Color c)
{
for (var i = 0; i < HeadsetConstants.MaxLeds; i++)
{
headset[i] = headset[i].Max(c);
}
return(headset);
}
public void ShouldNotEqualArbitraryObject()
{
var effect = CustomHeadsetEffect.Create();
var obj = new object();
Assert.False(effect == obj);
Assert.True(effect != obj);
Assert.False(effect.Equals(obj));
Assert.AreNotEqual(effect, obj);
}
public void ShouldNotEqualArrayWithInvalidLength()
{
var effect = new CustomHeadsetEffect(Color.Red);
var array = new[] { Color.Red, Color.Red, Color.Red };
Assert.False(effect == array);
Assert.True(effect != array);
Assert.False(effect.Equals(array));
Assert.AreNotEqual(effect, array);
}
public void ShouldNotEqualDifferentEffect()
{
var a = new CustomHeadsetEffect(Color.Red);
var b = new CustomHeadsetEffect(Color.Blue);
Assert.False(a == b);
Assert.True(a != b);
Assert.False(a.Equals(b));
Assert.AreNotEqual(a, b);
}
public void ShouldEqualIdenticalEffect()
{
var a = new CustomHeadsetEffect(Color.Red);
var b = new CustomHeadsetEffect(Color.Red);
Assert.True(a == b);
Assert.False(a != b);
Assert.True(a.Equals(b));
Assert.AreEqual(a, b);
}
public void ShouldGetCorrectColor()
{
var colors = new Color[HeadsetConstants.MaxLeds];
colors[3] = Color.Red;
var effect = new CustomHeadsetEffect(colors);
Assert.That(effect[3], Is.EqualTo(colors[3]));
}
public void ShouldThrowOnInvalidListCount()
{
var colors = new Color[1];
// ReSharper disable once NotAccessedVariable
CustomHeadsetEffect dummy;
Assert.That(
() => dummy = new CustomHeadsetEffect(colors),
Throws.InstanceOf <ArgumentException>().With.Property("ParamName").EqualTo("colors"));
}
private void Render(CustomHeadsetEffect headset, Color c)
{
if (_angle > 90)
{
return;
}
var i = _angle % HeadsetConstants.MaxLeds;
headset[i] = headset[i].Max(c);
}
public void ShouldResetToBlackWithClear()
{
var effect = CustomHeadsetEffect.Create();
effect.Set(Color.Red);
effect.Clear();
for (var i = 0; i < HeadsetConstants.MaxLeds; i++)
{
Assert.That(effect[i], Is.EqualTo(Color.Black));
}
}
public async Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
var keyboardGrid = CustomKeyboardEffect.Create();
var mouseGrid = CustomMouseEffect.Create();
var mousepadGrid = CustomMousepadEffect.Create();
var headsetGrid = CustomHeadsetEffect.Create();
var chromaLinkGrid = CustomChromaLinkEffect.Create();
foreach (var k in virtualGrid)
{
switch (k.Type)
{
case KeyType.Invalid:
break;
case KeyType.Keyboard:
var kbVal = (Key)Enum.Parse(typeof(Key), k.FriendlyName);
keyboardGrid[kbVal] = ToColoreColor(k.Color);
break;
case KeyType.Mouse:
var mouseVal = (GridLed)Enum.Parse(typeof(GridLed), k.FriendlyName);
mouseGrid[mouseVal] = ToColoreColor(k.Color);
break;
case KeyType.Mousepad:
mousepadGrid[k.KeyCode] = ToColoreColor(k.Color);
break;
case KeyType.Headset:
headsetGrid[k.KeyCode] = ToColoreColor(k.Color);
break;
case KeyType.ChromaLink:
chromaLinkGrid[k.KeyCode] = ToColoreColor(k.Color);
break;
}
}
await this._chromaInterface.Keyboard.SetCustomAsync(keyboardGrid);
await this._chromaInterface.Mouse.SetGridAsync(mouseGrid);
await this._chromaInterface.Mousepad.SetCustomAsync(mousepadGrid);
await this._chromaInterface.Headset.SetCustomAsync(headsetGrid);
await this._chromaInterface.ChromaLink.SetCustomAsync(chromaLinkGrid);
}
public void ShouldNotEqualDifferentArray()
{
var effect = new CustomHeadsetEffect(Color.Red);
var array = new Color[HeadsetConstants.MaxLeds];
for (var i = 0; i < HeadsetConstants.MaxLeds; i++)
{
array[i] = Color.Blue;
}
Assert.False(effect == array);
Assert.True(effect != array);
Assert.False(effect.Equals(array));
Assert.AreNotEqual(effect, array);
}
public void ShouldSetCorrectColorsFromList()
{
var colors = new Color[HeadsetConstants.MaxLeds];
colors[0] = Color.Red;
colors[1] = Color.Blue;
colors[2] = Color.Green;
var effect = new CustomHeadsetEffect(colors);
for (var i = 0; i < HeadsetConstants.MaxLeds; i++)
{
Assert.That(effect[i], Is.EqualTo(colors[i]));
}
}
public void ShouldThrowWhenOutOfRangeSet()
{
var custom = CustomHeadsetEffect.Create();
Assert.That(
() => custom[-1] = Color.Red,
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("led")
.And.Property("ActualValue")
.EqualTo(-1));
Assert.That(
() => custom[HeadsetConstants.MaxLeds] = Color.Red,
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("led")
.And.Property("ActualValue")
.EqualTo(HeadsetConstants.MaxLeds));
}
public void ShouldThrowWhenOutOfRangeGet()
{
var custom = CustomHeadsetEffect.Create();
// ReSharper disable once NotAccessedVariable
Color dummy;
Assert.That(
() => dummy = custom[-1],
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("led")
.And.Property("ActualValue")
.EqualTo(-1));
Assert.That(
() => dummy = custom[HeadsetConstants.MaxLeds],
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("led")
.And.Property("ActualValue")
.EqualTo(HeadsetConstants.MaxLeds));
}
public override Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
if (!this.Initialized)
{
return(Task.CompletedTask);
}
var headset = CustomHeadsetEffect.Create();
var actualIdx = 0;
var keyIdx = 0;
foreach (var cell in virtualGrid)
{
if (keyIdx++ % 2 != 0)
{
continue;
}
headset[actualIdx++] = ToColoreColor(cell.Color);
}
return(this.ChromaInterface !.Headset.SetCustomAsync(headset));
}
public void ShouldHaveZeroHashCodeOnDefaultInstance()
{
var effect = new CustomHeadsetEffect();
Assert.Zero(effect.GetHashCode());
}
/// <inheritdoc />
/// <summary>
/// Initializes a new instance of the <see cref="HeadsetImplementation" /> class.
/// </summary>
/// <param name="api">Reference to the Chroma API instance in use.</param>
public HeadsetImplementation(IChromaApi api)
: base(api)
{
Log.Info("Headset is initializing");
_custom = CustomHeadsetEffect.Create();
}
