{
			ipList:       []string{"127.0.0.1", "10.0.0.1", "192.168.0.1"},
			sortedIPList: []string{"10.0.0.1", "192.168.0.1", "127.0.0.1"},
		},
	}
	for i, testCase := range testCases {
		gotIPList := sortIPs(testCase.ipList)
		if !reflect.DeepEqual(testCase.sortedIPList, gotIPList) {
			t.Errorf("Test %d: Expected %s, got %s", i+1, testCase.sortedIPList, gotIPList)
		}
	}
}

func TestMustGetLocalIP4(t *testing.T) {

        List<SortBuilder<?>> sorts = queryContext.sortBuilders();
        assertNotNull(sorts);
        assertTrue(sorts.isEmpty());

        SortBuilder<?> sort = SortBuilders.fieldSort("field");
        queryContext.addSorts(sort);

        sorts = queryContext.sortBuilders();
        assertEquals(1, sorts.size());
        assertEquals(sort, sorts.get(0));
    }

Ce "attendre quelque chose d'autre" fait généralement référence à des opérations <abbr title="Input/Output ou Entrées et Sorties ">I/O</abbr> qui sont relativement "lentes" (comparées à la vitesse du processeur et de la mémoire RAM) telles qu'attendre que :

* de la donnée soit envoyée par le client à travers le réseau

        DataStoreFactory testFactory = new DataStoreFactory();
        List<String> names = testFactory.loadDataStoreNameList();
        assertNotNull(names);
    }

    // Test loadDataStoreNameList sorts results
    public void test_loadDataStoreNameList_sorted() {
        DataStoreFactory testFactory = new DataStoreFactory() {
            @Override
            protected List<String> loadDataStoreNameList() {

			},
			NoAuditLog: true,
		})
	if err != nil {
		err = fmt.Errorf("decommissionObject: PutObject() %w", err)
	}
	return err
}

// versionsSorter sorts FileInfo slices by version.
//
//msgp:ignore versionsSorter
type versionsSorter []FileInfo

func (v versionsSorter) reverse() {
	sort.Slice(v, func(i, j int) bool {
		return v[i].ModTime.Before(v[j].ModTime)