testing

src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64ValidatorHelper.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace System.Buffers.Text
 {
@@ -11,6 +12,8 @@ internal static bool IsValid<T, TBase64Validatable>(TBase64Validatable validatab
             where TBase64Validatable : IBase64Validatable<T>
             where T : struct
         {
+            if (!base64Text.IsEmpty && Unsafe.IsNullRef(ref MemoryMarshal.GetReference(base64Text))) throw new InvalidOperationException("Base64Helper1: Span is empty or not initialized properly. " + base64Text.Length);
+
             int length = 0, paddingCount = 0;
             T lastChar = default;
 
@@ -19,6 +22,8 @@ internal static bool IsValid<T, TBase64Validatable>(TBase64Validatable validatab
 #if NET
                 while (!base64Text.IsEmpty)
                 {
+                    if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(base64Text))) throw new InvalidOperationException("Base64Helper2: Span is empty or not initialized properly. " + base64Text.Length+ " "+length);
+
                     int index = validatable.IndexOfAnyExcept(base64Text);
                     if ((uint)index >= (uint)base64Text.Length)
                     {

src/libraries/System.Private.CoreLib/src/System/SearchValues/IndexOfAnyAsciiSearcher.cs

@@ -288,6 +288,8 @@ private static TResult IndexOfAnyCore<TResult, TNegator, TOptimizations, TUnique
             where TUniqueLowNibble : struct, SearchValues.IRuntimeConst
             where TResultMapper : struct, IResultMapper<short, TResult>
         {
+            if (searchSpaceLength != 0 && Unsafe.IsNullRef(ref searchSpace)) throw new InvalidOperationException("Span is empty or not initialized properly. " + searchSpaceLength);
+
             ref short currentSearchSpace = ref searchSpace;
 
             if (searchSpaceLength < Vector128<ushort>.Count)

src/mono/sample/wasm/browser/Program.cs

@@ -2,20 +2,124 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Buffers.Text;
 using System.Runtime.InteropServices.JavaScript;
 using System.Runtime.InteropServices;
+using System.Linq;
+using System.Text;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
 namespace Sample
 {
+    public interface IBase64Validatable<T>
+    {
+    }
+
+    public readonly struct Base64CharValidatable : IBase64Validatable<char>
+    {
+        private static readonly string s_validBase64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    }
+
     public partial class Test
     {
-        public static int Main(string[] args)
+        /*
+        public static bool IsValid<T, TBase64Validatable>(TBase64Validatable validatable, ReadOnlySpan<T> base64Text, out int decodedLength)
+            where TBase64Validatable : IBase64Validatable<T>
+            where T : struct
+        {
+            int length = 0, paddingCount = 0;
+            T lastChar = default;
+
+            if (!base64Text.IsEmpty)
+            {
+                if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(base64Text))) 
+                {
+                    decodedLength = 0;
+                    return false;
+                }
+            }
+
+            decodedLength = base64Text.Length;
+            return true;
+        }
+
+        public static bool IsValid(ReadOnlySpan<char> base64Text, out int decodedLength) =>
+            IsValid(default(Base64CharValidatable), base64Text, out decodedLength);
+
+        public unsafe static int Main(string[] args)
         {
-            DisplayMeaning(42);
+            try
+            {
+                var text = "YQ==";
+                var chars = text.ToArray();
+                var span = (ReadOnlySpan<char>)chars;
+                var t = IsValid(span, out int decodedLength);
+                Console.WriteLine($"{text} -> {t}:{decodedLength} {span.Length}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex);
+                return -1;
+            }
+            return 0;
+        }*/
+
+        public unsafe static int Main(string[] args)
+        {
+            try
+            {
+                var text = "YQ==";
+                var chars = text.ToArray();
+                var span = (ReadOnlySpan<char>)chars;
+                var t = Base64.IsValid(span, out int decodedLength);
+                Console.WriteLine($"{text} -> {t}:{decodedLength} {span.Length}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex);
+                return -1;
+            }
             return 0;
         }
 
-        [JSImport("Sample.Test.displayMeaning", "main.js")]
-        internal static partial void DisplayMeaning(int meaning);
+        /*
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, "System.Buffers.Text.Base64Helper", "System.Private.CoreLib")]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, "System.Buffers.Text.Base64", "System.Private.CoreLib")]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, "System.Buffers.IndexOfAnyAsciiSearcher", "System.Private.CoreLib")]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, "System.Buffers.IndexOfAnyAsciiSearcher.AsciiState", "System.Private.CoreLib")]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, "System.Buffers.IndexOfAnyAsciiSearcher.AnyByteState", "System.Private.CoreLib")]
+        public unsafe static int Main(string[] args)
+        {
+            try
+            {
+                Console.WriteLine("Hello from Sample.Test.Main 1");
+                var utf8WithByteToBeIgnored = "YQ==";
+                var expectedLength = 1;
+                var utf8BytesWithByteToBeIgnored = utf8WithByteToBeIgnored.ToArray();
+
+                //Console.WriteLine("Hello from Sample.Test.Main 2");
+                //Console.WriteLine(Base64.IsValid((ReadOnlySpan<char>)utf8BytesWithByteToBeIgnored));
+                //Console.WriteLine("Hello from Sample.Test.Main 3");
+                var utf8BytesWithByteToBeIgnored2 = utf8WithByteToBeIgnored.ToArray();
+                var utf8BytesWithByteToBeIgnored2RS = (ReadOnlySpan<char>)utf8BytesWithByteToBeIgnored2;
+                fixed (char* charsPtr = &MemoryMarshal.GetReference(utf8BytesWithByteToBeIgnored2RS))
+                {
+                    Console.WriteLine($"Hello from Sample.Test.Main 4 {(IntPtr)charsPtr}");
+                    Console.WriteLine(Base64.IsValid(utf8BytesWithByteToBeIgnored2RS, out int decodedLength));
+                    Console.WriteLine($"expectedLength: {expectedLength}, decodedLength: {decodedLength} {utf8BytesWithByteToBeIgnored2.Length}");
+
+                    Console.WriteLine("Hello from Sample.Test.Main E");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Exception: {ex}");
+                Console.WriteLine($"Exception: {ex.Message}");
+                Console.WriteLine($"Exception: {ex.StackTrace}");
+                return -1;
+            }
+            return 0;
+        }*/
     }
 }

src/mono/sample/wasm/browser/Wasm.Browser.Sample.csproj

@@ -3,4 +3,19 @@
   <ItemGroup>
     <WasmExtraFilesToDeploy Include="main.js" />
   </ItemGroup>
+
+  <PropertyGroup>
+    <!-- 
+    <PublishTrimmed>true</PublishTrimmed>
+    <PublishTrimmed>false</PublishTrimmed>
+    -->
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ShouldILStrip>false</ShouldILStrip>
+    <WasmStripILAfterAOT>false</WasmStripILAfterAOT>
+    <RunAOTCompilation>true</RunAOTCompilation>
+    <EnableAggressiveTrimming>false</EnableAggressiveTrimming>
+    <WasmNativeDebugSymbols>true</WasmNativeDebugSymbols>
+    <WasmNativeStrip>false</WasmNativeStrip>
+  </PropertyGroup>
+
 </Project>

src/mono/sample/wasm/browser/main.js

@@ -3,25 +3,16 @@
 
 import { dotnet, exit } from './_framework/dotnet.js'
 
-function displayMeaning(meaning) {
-    document.getElementById("out").innerHTML = `${meaning}`;
-}
-
 try {
-    const { setModuleImports } = await dotnet
+    const { runMain } = await dotnet
         .withElementOnExit()
+        .withDiagnosticTracing(true)
+        .withEnvironmentVariable("MONO_LOG_LEVEL", "debug")
+        .withEnvironmentVariable("MONO_LOG_MASK", "all")
         .withExitOnUnhandledError()
         .create();
 
-    setModuleImports("main.js", {
-        Sample: {
-            Test: {
-                displayMeaning
-            }
-        }
-    });
-
-    await dotnet.run();
+    await runMain();
 }
 catch (err) {
     exit(2, err);

src/mono/wasm/build/WasmApp.Common.targets

@@ -596,8 +596,6 @@
       <_MonoAotCrossCompilerPath>@(MonoAotCrossCompiler->WithMetadataValue('RuntimeIdentifier',$(RuntimeIdentifier)))</_MonoAotCrossCompilerPath>
     </PropertyGroup>
 
-    <Error Condition="'$(RunAOTCompilation)' == 'true' and '$(PublishTrimmed)' != 'true'"
-           Text="AOT is not supported without IL trimming (PublishTrimmed=true required)." />
     <Error Condition="'$(RunAOTCompilation)' == 'true' and '$(Configuration)' == 'Debug' and '$(_WasmAllowAOTDebug)' != 'true'"
            Text="AOT is not supported in debug configuration (Configuration=Release required)." />
     <Error Condition="'@(_WasmAssembliesInternal)' == ''" Text="Item _WasmAssembliesInternal is empty" />