github.com/cristalhq/base64@v0.1.2/decoder_test.go (about)

     1  package base64
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/base64"
     6  	"testing"
     7  )
     8  
     9  func TestDecoder(t *testing.T) {
    10  	for i := 0; i < 1000; i++ {
    11  		srcBytes := make([]byte, i)
    12  		for j := 0; j < i; j++ {
    13  			srcBytes[j] = stdLutSe[j%len(stdLutSe)]
    14  		}
    15  		src := string(srcBytes)
    16  
    17  		stdResult, stdErr := base64.StdEncoding.DecodeString(src)
    18  		ownResult, ownErr := StdEncoding.DecodeString(src)
    19  		if (stdErr != nil && ownErr == nil) || (stdErr == nil && ownErr != nil) {
    20  			t.Log("expected:", stdErr)
    21  			t.Log("actual:  ", ownErr)
    22  			t.Fatal()
    23  		} else if stdErr == nil && !bytes.Equal(stdResult, ownResult) {
    24  			t.Log("src:     ", src)
    25  			t.Log("expected:", stdResult)
    26  			t.Log("actual:  ", ownResult)
    27  			t.Fatal()
    28  		}
    29  
    30  		stdResult, stdErr = base64.RawStdEncoding.DecodeString(src)
    31  		ownResult, ownErr = RawStdEncoding.DecodeString(src)
    32  		if (stdErr != nil && ownErr == nil) || (stdErr == nil && ownErr != nil) {
    33  			t.Log("expected:", stdErr)
    34  			t.Log("actual:  ", ownErr)
    35  			t.Fatal()
    36  		} else if stdErr == nil && !bytes.Equal(stdResult, ownResult) {
    37  			t.Log("src:     ", src)
    38  			t.Log("expected:", stdResult)
    39  			t.Log("actual:  ", ownResult)
    40  			t.Fatal()
    41  		}
    42  	}
    43  
    44  	for i := 1; i < 200; i++ {
    45  		for j := 0; j < 10000; j++ {
    46  			valueBytes := generateRandomBytes(i)
    47  
    48  			badValue := b2s(valueBytes)
    49  			_, stdErr := base64.StdEncoding.DecodeString(badValue)
    50  			_, ownErr := StdEncoding.DecodeString(badValue)
    51  			if (stdErr != nil && ownErr == nil) || (stdErr == nil && ownErr != nil) {
    52  				t.Log(stdErr)
    53  				t.Log(valueBytes)
    54  				t.Fatal()
    55  			}
    56  
    57  			value := base64.StdEncoding.EncodeToString(valueBytes)
    58  			stdResult, err := base64.StdEncoding.DecodeString(value)
    59  			if err != nil {
    60  				t.Fatal()
    61  			}
    62  			ownResult, err := StdEncoding.DecodeString(value)
    63  			if err != nil {
    64  				t.Fatal()
    65  			}
    66  			if !bytes.Equal(stdResult, ownResult) {
    67  				t.Log("expected:", stdResult)
    68  				t.Log("actual:  ", ownResult)
    69  				t.Fatal()
    70  			}
    71  
    72  			value = base64.RawStdEncoding.EncodeToString(valueBytes)
    73  			stdResult, err = base64.RawStdEncoding.DecodeString(value)
    74  			if err != nil {
    75  				t.Fatal()
    76  			}
    77  			ownResult, err = RawStdEncoding.DecodeString(value)
    78  			if err != nil {
    79  				t.Fatal()
    80  			}
    81  			if !bytes.Equal(stdResult, ownResult) {
    82  				t.Log("expected:", stdResult)
    83  				t.Log("actual:  ", ownResult)
    84  				t.Fatal()
    85  			}
    86  
    87  			value = base64.URLEncoding.EncodeToString(valueBytes)
    88  			stdResult, err = base64.URLEncoding.DecodeString(value)
    89  			if err != nil {
    90  				t.Fatal()
    91  			}
    92  			ownResult, err = URLEncoding.DecodeString(value)
    93  			if err != nil {
    94  				t.Fatal()
    95  			}
    96  			if !bytes.Equal(stdResult, ownResult) {
    97  				t.Log("expected:", stdResult)
    98  				t.Log("actual:  ", ownResult)
    99  				t.Fatal()
   100  			}
   101  
   102  			value = base64.RawURLEncoding.EncodeToString(valueBytes)
   103  			stdResult, err = base64.RawURLEncoding.DecodeString(value)
   104  			if err != nil {
   105  				t.Fatal()
   106  			}
   107  			ownResult, err = RawURLEncoding.DecodeString(value)
   108  			if err != nil {
   109  				t.Fatal()
   110  			}
   111  			if !bytes.Equal(stdResult, ownResult) {
   112  				t.Log("expected:", stdResult)
   113  				t.Log("actual:  ", ownResult)
   114  				t.Fatal()
   115  			}
   116  		}
   117  	}
   118  }
   119  
   120  func BenchmarkDecoder(b *testing.B) {
   121  	b.ReportAllocs()
   122  	var err error
   123  
   124  	length := base64.StdEncoding.DecodedLen(len(stdBase64ValueBytes))
   125  	byteResult = make([]byte, length)
   126  	b.Run("std/Decode", func(b *testing.B) {
   127  		for n := 0; n < b.N; n++ {
   128  			resultN, err = base64.StdEncoding.Decode(byteResult, stdBase64ValueBytes)
   129  			if err != nil {
   130  				b.Fatal()
   131  			}
   132  		}
   133  	})
   134  	b.Run("std/DecodeString", func(b *testing.B) {
   135  		for n := 0; n < b.N; n++ {
   136  			byteResult, err = base64.StdEncoding.DecodeString(stdBase64ValueString)
   137  			if err != nil {
   138  				b.Fatal()
   139  			}
   140  		}
   141  	})
   142  
   143  	length = StdEncoding.DecodedLen(len(stdBase64ValueBytes))
   144  	byteResult = make([]byte, length)
   145  	b.Run("own/Decode", func(b *testing.B) {
   146  		for n := 0; n < b.N; n++ {
   147  			resultN, err = StdEncoding.Decode(byteResult, stdBase64ValueBytes)
   148  			if err != nil {
   149  				b.Fatal()
   150  			}
   151  		}
   152  	})
   153  	b.Run("own/DecodeString", func(b *testing.B) {
   154  		for n := 0; n < b.N; n++ {
   155  			byteResult, err = StdEncoding.DecodeString(stdBase64ValueString)
   156  			if err != nil {
   157  				b.Fatal()
   158  			}
   159  		}
   160  	})
   161  }