memfs - directory_rw_test.go

     1  package memfs
     2  
     3  import (
     4  	"errors"
     5  	"io"
     6  	"io/fs"
     7  	"reflect"
     8  	"sync"
     9  	"testing"
    10  )
    11  
    12  var _ dNode = &directoryRW{}
    13  
    14  func testReadAllRW(d *directoryRW) ([]fs.DirEntry, error) {
    15  	return d.ReadDir(-1)
    16  }
    17  
    18  func testReadOnesRW(d *directoryRW) ([]fs.DirEntry, error) {
    19  	var read []fs.DirEntry
    20  
    21  	for {
    22  		des, err := d.ReadDir(1)
    23  		if errors.Is(err, io.EOF) {
    24  			return read, nil
    25  		} else if err != nil {
    26  			return nil, err
    27  		}
    28  
    29  		read = append(read, des...)
    30  	}
    31  }
    32  
    33  func testReadTwosRW(d *directoryRW) ([]fs.DirEntry, error) {
    34  	var read []fs.DirEntry
    35  
    36  	for {
    37  		des, err := d.ReadDir(2)
    38  		if errors.Is(err, io.EOF) {
    39  			return read, nil
    40  		} else if err != nil {
    41  			return nil, err
    42  		}
    43  
    44  		read = append(read, des...)
    45  	}
    46  }
    47  
    48  func makeDirectoryRW(dirs []*dirEnt) *directoryRW {
    49  	return &directoryRW{
    50  		mu: &sync.RWMutex{},
    51  		directory: directory{
    52  			dnode: &dnode{
    53  				entries: dirs,
    54  				mode:    fs.ModeDir | fs.ModePerm,
    55  			},
    56  		},
    57  	}
    58  }
    59  
    60  func TestReadDirRW(t *testing.T) {
    61  	for n, test := range [...][]*dirEnt{
    62  		{
    63  			{
    64  				name: "1",
    65  			},
    66  		},
    67  		{
    68  			{
    69  				name: "1",
    70  			},
    71  			{
    72  				name: "2",
    73  			},
    74  		},
    75  		{
    76  			{
    77  				name: "1",
    78  			},
    79  			{
    80  				name: "3",
    81  			},
    82  			{
    83  				name: "3",
    84  			},
    85  		},
    86  		{
    87  			{
    88  				name: "1",
    89  			},
    90  			{
    91  				name: "2",
    92  			},
    93  			{
    94  				name: "3",
    95  			},
    96  			{
    97  				name: "4",
    98  			},
    99  		},
   100  	} {
   101  		if all, err := testReadAllRW(makeDirectoryRW(test)); err != nil {
   102  			t.Errorf("test %d.1: received unexpected error: %s", n+1, err)
   103  		} else if !reflect.DeepEqual(asDirEntries(test), all) {
   104  			t.Errorf("test %d.1: 'all' does not equal", n+1)
   105  		}
   106  
   107  		if ones, err := testReadOnesRW(makeDirectoryRW(test)); err != nil {
   108  			t.Errorf("test %d.2: received unexpected error: %s", n+1, err)
   109  		} else if !reflect.DeepEqual(asDirEntries(test), ones) {
   110  			t.Errorf("test %d.2: 'ones' does not equal", n+1)
   111  		}
   112  
   113  		if twos, err := testReadTwosRW(makeDirectoryRW(test)); err != nil {
   114  			t.Errorf("test %d.3: received unexpected error: %s", n+1, err)
   115  		} else if !reflect.DeepEqual(asDirEntries(test), twos) {
   116  			t.Errorf("test %d.3: 'twos' does not equal", n+1)
   117  		}
   118  	}
   119  }
   120  
   121  func TestDnodeRemoveRW(t *testing.T) {
   122  	d := dnodeRW{
   123  		dnode: dnode{
   124  			entries: []*dirEnt{
   125  				{
   126  					name: "1",
   127  				},
   128  				{
   129  					name: "2",
   130  				},
   131  				{
   132  					name: "3",
   133  				},
   134  				{
   135  					name: "4",
   136  				},
   137  			},
   138  			mode: fs.ModeDir | fs.ModePerm,
   139  		},
   140  	}
   141  
   142  	if err := d.removeEntry("2"); err != nil {
   143  		t.Errorf("test 1: unexpected error: %s", err)
   144  
   145  		return
   146  	}
   147  
   148  	if err := d.removeEntry("2"); !errors.Is(err, fs.ErrNotExist) {
   149  		t.Errorf("test 2: unexpected Not Exist, got %s", err)
   150  
   151  		return
   152  	}
   153  
   154  	if len(d.entries) != 3 {
   155  		t.Errorf("test 3: expecting 3 entries, got %d", len(d.entries))
   156  
   157  		return
   158  	}
   159  
   160  	expecting := []*dirEnt{
   161  		{
   162  			name: "1",
   163  		},
   164  		{
   165  			name: "3",
   166  		},
   167  		{
   168  			name: "4",
   169  		},
   170  	}
   171  
   172  	if !reflect.DeepEqual(expecting, d.entries) {
   173  		t.Errorf("test 4: expecting %v, got %v", expecting, d.entries)
   174  	}
   175  }
   176