Added tests for ConvolverNode.

Author: KristofferStrube

src/KristofferStrube.Blazor.WebAudio/AudioNodes/ConvolverNode.cs

@@ -50,8 +50,14 @@ protected ConvolverNode(IJSRuntime jSRuntime, IJSObjectReference jSReference, Cr
     /// </summary>
     public async Task<AudioBuffer?> GetBufferAsync()
     {
+        await using ValueReference bufferAttribute = new(JSRuntime, JSReference, "buffer");
+        if (await bufferAttribute.GetTypeNameAsync() is "null")
+        {
+            return null;
+        }
+
         IJSObjectReference helper = await webAudioHelperTask.Value;
-        IJSObjectReference? jSInstance = await helper.InvokeAsync<IJSObjectReference?>("getAttribute", JSReference, "buffer");
+        IJSObjectReference jSInstance = await helper.InvokeAsync<IJSObjectReference>("getAttribute", JSReference, "buffer");
         return jSInstance is null ? null : await AudioBuffer.CreateAsync(JSRuntime, jSInstance, new() { DisposesJSReference = true });
     }
 
@@ -70,7 +76,7 @@ public async Task SetBufferAsync(AudioBuffer? value)
     }
 
     /// <summary>
-    /// Gets the flag for whether the impulse response from the buffer will be scaled by an equal-power normalization when the buffer atttribute is set.<br />
+    /// Gets the flag for whether the impulse response from the buffer will be scaled by an equal-power normalization when the buffer attribute is set.<br />
     /// </summary>
     /// <remarks>
     /// Its default value is <see langword="true"/> in order to achieve a more uniform output level from the convolver when loaded with diverse impulse responses.
@@ -87,7 +93,7 @@ public async Task<bool> GetNormalizeAsync()
     }
 
     /// <summary>
-    /// Sets the flag for whether the impulse response from the buffer will be scaled by an equal-power normalization when the buffer atttribute is set.<br />
+    /// Sets the flag for whether the impulse response from the buffer will be scaled by an equal-power normalization when the buffer attribute is set.<br />
     /// </summary>
     /// <remarks>
     /// Its default value is <see langword="true"/> in order to achieve a more uniform output level from the convolver when loaded with diverse impulse responses.

src/KristofferStrube.Blazor.WebAudio/Options/ConvolverOptions.cs

@@ -17,6 +17,9 @@ public class ConvolverOptions : AudioNodeOptions
     /// <summary>
     /// The opposite of the desired initial value for <see cref="ConvolverNode.GetNormalizeAsync"/>.
     /// </summary>
+    /// <remarks>
+    /// The default value is <see langword="false"/>.
+    /// </remarks>
     [JsonPropertyName("disableNormalization")]
     public bool DisableNormalization { get; set; } = false;
 

tests/IntegrationTests/AudioNodeTests/ConvolverNodeTest.cs

@@ -1,5 +1,7 @@
-using KristofferStrube.Blazor.WebIDL.Exceptions;
+using FluentAssertions;
+using KristofferStrube.Blazor.WebIDL.Exceptions;
 using Microsoft.JSInterop;
+using System;
 
 namespace IntegrationTests.AudioNodeTests;
 
@@ -12,4 +14,119 @@ public override async Task<ConvolverNode> CreateAsync(IJSRuntime jSRuntime, Audi
     {
         [ChannelCountMode.Max] = typeof(NotSupportedErrorException)
     };
+
+    [Test]
+    public async Task GetBufferAsync_ShouldReturnNull_WhenItHasNoBuffer()
+    {
+        // Arrange
+        await using ConvolverNode node = await ConvolverNode.CreateAsync(JSRuntime, AudioContext);
+
+        // Act
+        AudioBuffer? buffer = await node.GetBufferAsync();
+
+        // Assert
+        _ = buffer.Should().BeNull();
+    }
+
+    [Test]
+    public async Task GetBufferAsync_ShouldRetrieveBuffer_WhenItHasBuffer()
+    {
+        // Arrange
+        await using AudioBuffer buffer = await AudioBuffer.CreateAsync(JSRuntime, new AudioBufferOptions()
+        {
+            Length = 1,
+            SampleRate = await AudioContext.GetSampleRateAsync()
+        });
+
+        await using ConvolverNode node = await ConvolverNode.CreateAsync(JSRuntime, AudioContext, new()
+        {
+            Buffer = buffer
+        });
+
+        // Act
+        AudioBuffer? readBuffer = await node.GetBufferAsync();
+
+        // Assert
+        _ = readBuffer.Should().NotBeNull();
+    }
+
+    [Test]
+    public async Task SetBufferAsync_ShouldUpdateTheBuffer()
+    {
+        // Arrange
+        await using ConvolverNode node = await ConvolverNode.CreateAsync(JSRuntime, AudioContext);
+
+        await using AudioBuffer buffer = await AudioBuffer.CreateAsync(JSRuntime, new AudioBufferOptions()
+        {
+            Length = 1,
+            SampleRate = await AudioContext.GetSampleRateAsync()
+        });
+
+        // Act
+        await node.SetBufferAsync(buffer);
+
+        // Assert
+        AudioBuffer? readBuffer = await node.GetBufferAsync();
+        _ = readBuffer.Should().NotBeNull();
+    }
+
+    [Test]
+    public async Task SetBufferAsync_WithNullArgument_ShouldClearBuffer()
+    {
+        // Arrange
+        await using AudioBuffer buffer = await AudioBuffer.CreateAsync(JSRuntime, new AudioBufferOptions()
+        {
+            Length = 1,
+            SampleRate = await AudioContext.GetSampleRateAsync()
+        });
+
+        await using ConvolverNode node = await ConvolverNode.CreateAsync(JSRuntime, AudioContext, new()
+        {
+            Buffer = buffer
+        });
+
+        // Act
+        await node.SetBufferAsync(null);
+
+        // Assert
+        AudioBuffer? readBuffer = await node.GetBufferAsync();
+        _ = readBuffer.Should().BeNull();
+    }
+
+    [Test]
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task GetNormalizeAsync_ShouldRetrieveNormalize(bool normalize)
+    {
+        // Arrange
+        await using ConvolverNode node = await ConvolverNode.CreateAsync(JSRuntime, AudioContext, new()
+        {
+            DisableNormalization = !normalize
+        });
+
+        // Act
+        bool readNormalize = await node.GetNormalizeAsync();
+
+        // Assert
+        _ = readNormalize.Should().Be(normalize);
+    }
+
+    [Test]
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task SetNormalizeAsync_ShouldRetrieveNormalize(bool normalize)
+    {
+        // Arrange
+        await using ConvolverNode node = await ConvolverNode.CreateAsync(JSRuntime, AudioContext, new()
+        {
+            DisableNormalization = normalize // this is the inverse as the options parameter is whether normalization should be disabled.
+        });
+
+        // Act
+        await node.SetNormalizeAsync(normalize);
+
+        // Assert
+        bool readNormalize = await node.GetNormalizeAsync();
+        _ = readNormalize.Should().Be(normalize);
+    }
 }