38 var repeatedCycleStrings []string

39

40 // randomStrings consists of strings of 100 mixed-case letters and numbers.

41 var randomStrings []string

71

72 // Generate a set of random strings, each of length 100.

73 randomStrings = make([]string, largeDataSize)

74 for i := range randomStrings {

84 }

85 }

86 randomStrings[i] = string(bb.Bytes())

87 }

88

139 // testSortArguments runs a given sort function with the most

140 // basic of input sequences in order to test its robustness.

141 func testSortArguments(t *testing.T, f func([]string)) {

142 // these should silently do nothing

143 f(nil)

31 }

32

33 func TestMarshalUnmarshal(t *testing.T) {

34 rand := rand.New(rand.NewSource(0))

35

79 }

80

81 func TestFuzz(t *testing.T) {

82 rand := rand.New(rand.NewSource(0))

83 for _, iface := range tests {

101 }

102

103 func randomString(n int, rand *rand.Rand) string {

104 b := randomBytes(n, rand)

105 return string(b)

14 )

15

16 func TestAccAWSDBParameterGroup_basic(t *testing.T) {

17 var v rds.DBParameterGroup

18

84 }

85

86 func TestAccAWSDBParameterGroupOnly(t *testing.T) {

87 var v rds.DBParameterGroup

88

109 }

110

111 func TestResourceAWSDBParameterGroupName_validation(t *testing.T) {

112 cases := []struct {

113 Value string

50

51 DDMFormField ddmFormField = createDDMFormField(

52 fieldName, RandomTestUtil.randomString(),

53 DDMFormFieldTypeConstants.DOCUMENT_LIBRARY, "document-library",

54 true, false, true);

166 /* Source: https://stackoverflow.com/questions/41107/

167 how-to-generate-a-random-alpha-numeric-string */

168 public static String getRandomString(int length) {

169 if (length < 1) throw new IllegalArgumentException();

170

27 }

28

29 func TestMarshalUnmarshal(t *testing.T) {

30 rand := rand.New(rand.NewSource(0))

31 for i, iface := range tests {

69 }

70

71 func TestFuzz(t *testing.T) {

72 rand := rand.New(rand.NewSource(0))

73 for _, iface := range tests {

91 }

92

93 func randomString(n int, rand *rand.Rand) string {

94 b := randomBytes(n, rand)

95 return string(b)

25 }

26

27 func TestEnvLenDup(t *testing.T) {

28 env := &Env{

29 "foo=bar",

83 }

84

85 func TestSetenvInt(t *testing.T) {

86 job := mkJob(t, "dummy")

87

152 res := make([][2]string, l)

153 for i := 0; i < l; i++ {

154 t := [2]string{testutils.RandomString(5), testutils.RandomString(20)}

155 res[i] = t

156 }

27 {

28 static List<JsonUserGroups> userGroupList = new List<JsonUserGroups>();

29 const String randomStringGenerator = "abcdefghijklmnopqrstuvwxyz0123456789";

30 private static Random random = new Random((int)DateTime.Now.Ticks);

31

48 }

49 }

50 private static string RandomStringGenerator(int length)

51 {

52 var randomBuilder = new StringBuilder();

53 for (var i = 0; i < length; i++)

54 {

55 var c = randomStringGenerator[random.Next(0, randomStringGenerator.Length)];

56 randomBuilder.Append(c);

57 }

7 )

8

9 func randomString() string {

10 n := 3 + rand.Intn(10)

11 bs := make([]byte, n)

16 }

17

18 func Test(t *testing.T) {

19 tree := New()

20 tree.Insert("test", 1)

59 strs := make([]string, b.N)

60 for i := 0; i<b.N; i++ {

61 strs[i] = randomString()

62 }

63 b.StartTimer()

96 //message to the server you would presumably want to associate the correlation ID with this

97 //message somehow...a Map works good

98 String correlationId = this.createRandomString();

99 txtMessage.setJMSCorrelationID(correlationId);

100 this.producer.send(txtMessage);

105 }

106

107 private String createRandomString() {

108 Random random = new Random(System.currentTimeMillis());

109 long randomLong = random.nextLong();

17 // CreateDatabase will create a database with a randomly generated name.

18 // An error will be returned if the database was unable to be created.

19 func CreateDatabase(t *testing.T, client *gophercloud.ServiceClient, instanceID string) error {

20 name := tools.RandomString("ACPTTEST", 8)

35 // OS_DATASTORE_TYPE_ID environment variable.

36 // An error will be returned if the instance was unable to be created.

37 func CreateInstance(t *testing.T, client *gophercloud.ServiceClient) (*instances.Instance, error) {

38 if testing.Short() {

39 t.Skip("Skipping test that requires instance creation in short mode.")

45 }

46

47 name := tools.RandomString("ACPTTEST", 8)

48 t.Logf("Attempting to create instance: %s", name)

49

72 // CreateUser will create a user with a randomly generated name.

73 // An error will be returned if the user was unable to be created.

74 func CreateUser(t *testing.T, client *gophercloud.ServiceClient, instanceID string) error {

75 name := tools.RandomString("ACPTTEST", 8)

34 // Tests

35

36 func TestPubSub(t *testing.T) {

37 k := randomString(16)

28 )

29

30 func TestString(t *testing.T) {

31 valid := "0123456789abcdefghijklmnopqrstuvwxyz"

32 for _, l := range []int{0, 1, 2, 10, 123} {

44

45 // Confirm that panic occurs on invalid input.

46 func TestRangePanic(t *testing.T) {

47 defer func() {

48 if err := recover(); err == nil {

54 }

55

56 func TestIntn(t *testing.T) {

57 // 0 is invalid.

58 for _, max := range []int{1, 2, 10, 123} {

14 // CreateFloatingIP creates a floating IP on a given network and port. An error

15 // will be returned if the creation failed.

16 func CreateFloatingIP(t *testing.T, client *gophercloud.ServiceClient, networkID, portID string) (*floatingips.FloatingIP, error) {

17 t.Logf("Attempting to create floating IP on port: %s", portID)

18

35 // the OS_EXTGW_ID environment variable to be set. An error is returned if the

36 // creation failed.

37 func CreateExternalRouter(t *testing.T, client *gophercloud.ServiceClient) (*routers.Router, error) {

38 var router *routers.Router

39 choices, err := clients.AcceptanceTestChoicesFromEnv()

42 }

43

44 routerName := tools.RandomString("TESTACC-", 8)

45

46 t.Logf("Attempting to create external router: %s", routerName)

15 // CreateExternalNetwork will create an external network. An error will be

16 // returned if the creation failed.

17 func CreateExternalNetwork(t *testing.T, client *gophercloud.ServiceClient) (*networks.Network, error) {

18 networkName := tools.RandomString("TESTACC-", 8)

45 // CreatePortWithSecurityGroup will create a port with a security group

46 // attached. An error will be returned if the port could not be created.

47 func CreatePortWithSecurityGroup(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID, secGroupID string) (*ports.Port, error) {

48 portName := tools.RandomString("TESTACC-", 8)

71 // CreateSecurityGroup will create a security group with a random name.

72 // An error will be returned if one was failed to be created.

73 func CreateSecurityGroup(t *testing.T, client *gophercloud.ServiceClient) (*groups.SecGroup, error) {

74 secGroupName := tools.RandomString("TESTACC-", 8)

93 // and random port between 80 and 99.

94 // An error will be returned if one was failed to be created.

95 func CreateSecurityGroupRule(t *testing.T, client *gophercloud.ServiceClient, secGroupID string) (*rules.SecGroupRule, error) {

96 t.Logf("Attempting to create security group rule in group: %s", secGroupID)

97

8 )

9

10 func abs(t *testing.T, p string) string {

11 o, err := filepath.Abs(p)

12 if err != nil {

16 }

17

18 func TestFollowSymLinkNormal(t *testing.T) {

19 link := "testdata/fs/a/d/c/data"

20

65 }

66

67 func TestFollowSymLinkRandomString(t *testing.T) {

68 if _, err := FollowSymlinkInScope("toto", "testdata"); err == nil {

69 t.Fatal("Random string should fail but didn't")

14 // If it doesn't, it causes the tests to fail.

15 // t must be a valid testing context.

16 func Timeout(t *testing.T, f func()) {

17 onTimeout := time.After(100 * time.Millisecond)

18 onDone := make(chan bool)

28 }

29

30 // RandomString returns random string of specified length

31 func RandomString(length int) string {

16 }

17

18 func mkEngine(t *testing.T) *Engine {

19 // Use the caller function name as a prefix.

20 // This helps trace temp directories back to their test.

24 callerShortName := parts[len(parts)-1]

25 if globalTestID == "" {

26 globalTestID = utils.RandomString()[:4]

27 }

28 prefix := fmt.Sprintf("docker-test%s-%s-", globalTestID, callerShortName)

38 }

39

40 func mkJob(t *testing.T, name string, args ...string) *Job {

41 return mkEngine(t).Job(name, args...)

42 }

13 // CreateEmptyImage will create an image, but with no actual image data.

14 // An error will be returned if an image was unable to be created.

15 func CreateEmptyImage(t *testing.T, client *gophercloud.ServiceClient) (*images.Image, error) {

16 var image *images.Image

17

18 name := tools.RandomString("ACPTTEST", 16)

19 t.Logf("Attempting to create image: %s", name)

20

46 // A fatal error will occur if the image failed to delete. This works best when

47 // used as a deferred function.

48 func DeleteImage(t *testing.T, client *gophercloud.ServiceClient, image *images.Image) {

49 err := images.Delete(client, image.ID).ExtractErr()

50 if err != nil {

17 // CreateUploadImage will upload volume it as volume-baked image. An name of new image or err will be

18 // returned

19 func CreateUploadImage(t *testing.T, client *gophercloud.ServiceClient, volume *volumes.Volume) (volumeactions.VolumeImage, error) {

20 if testing.Short() {

21 t.Skip("Skipping test that requires volume-backed image uploading in short mode.")

22 }

23

24 imageName := tools.RandomString("ACPTTEST", 16)

25 uploadImageOpts := volumeactions.UploadImageOpts{

26 ImageName: imageName,

47 // DeleteUploadedImage deletes uploaded image. An error will be returned

48 // if the deletion request failed.

49 func DeleteUploadedImage(t *testing.T, client *gophercloud.ServiceClient, imageName string) error {

50 if testing.Short() {

51 t.Skip("Skipping test that requires volume-backed image removing in short mode.")

11 // CreateShareType will create a share type with a random name. An

12 // error will be returned if the share type was unable to be created.

13 func CreateShareType(t *testing.T, client *gophercloud.ServiceClient) (*sharetypes.ShareType, error) {

14 if testing.Short() {

15 t.Skip("Skipping test that requires share type creation in short mode.")

16 }

17

18 shareTypeName := tools.RandomString("ACPTTEST", 16)

19 t.Logf("Attempting to create share type: %s", shareTypeName)

20

39 // DeleteShareType will delete a share type. An error will occur if

40 // the share type was unable to be deleted.

41 func DeleteShareType(t *testing.T, client *gophercloud.ServiceClient, shareType *sharetypes.ShareType) {

42 err := sharetypes.Delete(client, shareType.ID).ExtractErr()

43 if err != nil {

31 // MakeNewPassword generates a new string that's guaranteed to be different than the given one.

32 func MakeNewPassword(oldPass string) string {

33 randomPassword := RandomString("", 16)

34 for randomPassword == oldPass {

35 randomPassword = RandomString("", 16)

38 }

39

40 // RandomString generates a string of given length, but random content.

41 // All content will be within the ASCII graphic character set.

42 // (Implementation from Even Shaw's contribution on

43 // http://stackoverflow.com/questions/12771930/what-is-the-fastest-way-to-generate-a-long-random-string-in-go).

44 func RandomString(prefix string, n int) string {

45 const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

46 var bytes = make([]byte, n)

11 )

12

13 func TestNetworksList(t *testing.T) {

14 client, err := clients.NewNetworkV2Client()

15 if err != nil {

32 }

33

34 func TestNetworksCRUD(t *testing.T) {

35 client, err := clients.NewNetworkV2Client()

36 if err != nil {

47 tools.PrintResource(t, network)

48

49 newName := tools.RandomString("TESTACC-", 8)

50 updateOpts := &networks.UpdateOpts{

51 Name: newName,

19 {

20 const int stringSampleSize = 1024 * 10;

21 var testString = CreateRandomString(stringSampleSize);

22 var copyTo = new char[stringSampleSize];

23

40 }

41

42 public string CreateRandomString(int size)

43 {

44 var randString = new char[size];

78 }

79

80 var value = CreateRandomString(100);

81 var len = value.Length;

82 var hasEscapeChars = false;

15 // AddUserRole will grant a role to a user in a tenant. An error will be

16 // returned if the grant was unsuccessful.

17 func AddUserRole(t *testing.T, client *gophercloud.ServiceClient, tenant *tenants.Tenant, user *users.User, role *roles.Role) error {

18 t.Logf("Attempting to grant user %s role %s in tenant %s", user.ID, role.ID, tenant.ID)

19

32 // has so many options. An error will be returned if the project was

33 // unable to be created.

34 func CreateTenant(t *testing.T, client *gophercloud.ServiceClient, c *tenants.CreateOpts) (*tenants.Tenant, error) {

35 name := tools.RandomString("ACPTTEST", 8)

58 // CreateUser will create a user with a random name and adds them to the given

59 // tenant. An error will be returned if the user was unable to be created.

60 func CreateUser(t *testing.T, client *gophercloud.ServiceClient, tenant *tenants.Tenant) (*users.User, error) {

61 userName := tools.RandomString("user_", 5)

81 // the tenant ID failed to be deleted. This works best when using it as

82 // a deferred function.

83 func DeleteTenant(t *testing.T, client *gophercloud.ServiceClient, tenantID string) {

84 err := tenants.Delete(client, tenantID).ExtractErr()

85 if err != nil {

11 // CreateSecurityService will create a security service with a random name. An

12 // error will be returned if the security service was unable to be created.

13 func CreateSecurityService(t *testing.T, client *gophercloud.ServiceClient) (*securityservices.SecurityService, error) {

14 if testing.Short() {

15 t.Skip("Skipping test that requires share network creation in short mode.")

16 }

17

18 securityServiceName := tools.RandomString("ACPTTEST", 16)

19 t.Logf("Attempting to create security service: %s", securityServiceName)

20

34 // DeleteSecurityService will delete a security service. An error will occur if

35 // the security service was unable to be deleted.

36 func DeleteSecurityService(t *testing.T, client *gophercloud.ServiceClient, securityService *securityservices.SecurityService) {

37 err := securityservices.Delete(client, securityService.ID).ExtractErr()

38 if err != nil {

14 var predictableRandomTest sync.Once

15

16 func TestPredictableRandom(t *testing.T) {

17 predictableRandomTest.Do(func() {

18 // predictable random sequence is predictable

24 }

25

26 func TestSeedFromBytes(t *testing.T) {

27 // should always return the same seed for the same bytes

28 tcs := []struct {

41 }

42

43 func TestRandomString(t *testing.T) {

44 for _, l := range []int{0, 1, 2, 3, 4, 8, 42} {

45 s := randomString(l)

13 )

14

15 func TestLayer3RouterList(t *testing.T) {

16 client, err := clients.NewNetworkV2Client()

17 if err != nil {

35 }

36

37 func TestLayer3ExternalRouterCreateDelete(t *testing.T) {

38 client, err := clients.NewNetworkV2Client()

39 if err != nil {

49 tools.PrintResource(t, router)

50

51 newName := tools.RandomString("TESTACC-", 8)

52 updateOpts := routers.UpdateOpts{

53 Name: newName,

20 )

21

22 func Test_PostActivityNoRequestError(t *testing.T) {

23

24 req := adProxy.PostAdminActivitiesRequest{

35 }

36

37 func Test_PostActivityNoRequestSuccess(t *testing.T) {

38

39 req := adProxy.PostAdminActivitiesRequest{

52 }

53

54 func Test_PostStoreSuccess(t *testing.T) {

55

56 rand.Seed(time.Now().UnixNano())

22 )

23

24 func randomString(n int) string {

25 var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

26 b := make([]rune, n)

31 }

32

33 func TestApps(t *testing.T) {

34 params := appsSetup(t)

35 appsCreateTest(t, params)

43 }

44

45 func appsSetup(t *testing.T) *utils.DeisTestConfig {

46 cfg := utils.GetGlobalConfig()

47 cfg.AppName = "appssample"

13 )

14

15 func TestSubnetsList(t *testing.T) {

16 client, err := clients.NewNetworkV2Client()

17 if err != nil {

34 }

35

36 func TestSubnetCRUD(t *testing.T) {

37 client, err := clients.NewNetworkV2Client()

38 if err != nil {

57

58 // Update Subnet

59 newSubnetName := tools.RandomString("TESTACC-", 8)

60 updateOpts := subnets.UpdateOpts{

61 Name: newSubnetName,

11 )

12

13 func TestSecGroupsList(t *testing.T) {

14 client, err := clients.NewComputeV2Client()

15 if err != nil {

32 }

33

34 func TestSecGroupsCreate(t *testing.T) {

35 client, err := clients.NewComputeV2Client()

36 if err != nil {

45 }

46

47 func TestSecGroupsUpdate(t *testing.T) {

48 client, err := clients.NewComputeV2Client()

49 if err != nil {

12 )

13

14 func TestVolumeAttachAttachment(t *testing.T) {

15 if testing.Short() {

16 t.Skip("Skipping test that requires server creation in short mode.")

53 }

54

55 func createVolume(t *testing.T, blockClient *gophercloud.ServiceClient) (*volumes.Volume, error) {

56 volumeName := tools.RandomString("ACPTTEST", 16)

69 }

70

71 func deleteVolume(t *testing.T, blockClient *gophercloud.ServiceClient, volume *volumes.Volume) {

72 err := volumes.Delete(blockClient, volume.ID).ExtractErr()

73 if err != nil {

16 // CreateFirewall will create a Firewaill with a random name and a specified

17 // policy ID. An error will be returned if the firewall could not be created.

18 func CreateFirewall(t *testing.T, client *gophercloud.ServiceClient, policyID string) (*firewalls.Firewall, error) {

19 firewallName := tools.RandomString("TESTACC-", 8)

46 // specified policy ID attached to a specified Router. An error will be

47 // returned if the firewall could not be created.

48 func CreateFirewallOnRouter(t *testing.T, client *gophercloud.ServiceClient, policyID string, routerID string) (*firewalls.Firewall, error) {

49 firewallName := tools.RandomString("TESTACC-", 8)

78 // CreatePolicy will create a Firewall Policy with a random name and given

79 // rule. An error will be returned if the rule could not be created.

80 func CreatePolicy(t *testing.T, client *gophercloud.ServiceClient, ruleID string) (*policies.Policy, error) {

81 policyName := tools.RandomString("TESTACC-", 8)

103 //source port, destination address and port. An error will be returned if

104 // the rule could not be created.

105 func CreateRule(t *testing.T, client *gophercloud.ServiceClient) (*rules.Rule, error) {

106 ruleName := tools.RandomString("TESTACC-", 8)

17 var numContainers = 2

18

19 func TestContainers(t *testing.T) {

20 client, err := clients.NewObjectStorageV1Client()

21 if err != nil {

26 cNames := make([]string, numContainers)

27 for i := 0; i < numContainers; i++ {

28 cNames[i] = tools.RandomString("gophercloud-test-container-", 8)

29 }

30

96 }

97

98 func TestListAllContainers(t *testing.T) {

99 client, err := clients.NewObjectStorageV1Client()

100 if err != nil {

20 // port with a random name. An error will be returned if the listener could not

21 // be created.

22 func CreateListener(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer) (*listeners.Listener, error) {

23 listenerName := tools.RandomString("TESTACCT-", 8)

49 // CreateLoadBalancer will create a load balancer with a random name on a given

50 // subnet. An error will be returned if the loadbalancer could not be created.

51 func CreateLoadBalancer(t *testing.T, client *gophercloud.ServiceClient, subnetID string) (*loadbalancers.LoadBalancer, error) {

52 lbName := tools.RandomString("TESTACCT-", 8)

79 // CreateMember will create a member with a random name, port, address, and

80 // weight. An error will be returned if the member could not be created.

81 func CreateMember(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer, pool *pools.Pool, subnetID, subnetCIDR string) (*pools.Member, error) {

82 memberName := tools.RandomString("TESTACCT-", 8)

116 // CreateMonitor will create a monitor with a random name for a specific pool.

117 // An error will be returned if the monitor could not be created.

118 func CreateMonitor(t *testing.T, client *gophercloud.ServiceClient, lb *loadbalancers.LoadBalancer, pool *pools.Pool) (*monitors.Monitor, error) {

119 monitorName := tools.RandomString("TESTACCT-", 8)

15 // CreateMember will create a load balancer member in a specified pool on a

16 // random port. An error will be returned if the member could not be created.

17 func CreateMember(t *testing.T, client *gophercloud.ServiceClient, poolID string) (*members.Member, error) {

18 protocolPort := tools.RandomInt(100, 1000)

19 address := tools.RandomInt(2, 200)

38 // CreateMonitor will create a monitor with a random name for a specific pool.

39 // An error will be returned if the monitor could not be created.

40 func CreateMonitor(t *testing.T, client *gophercloud.ServiceClient) (*monitors.Monitor, error) {

41 t.Logf("Attempting to create monitor.")

42

61 // CreatePool will create a pool with a random name. An error will be returned

62 // if the pool could not be deleted.

63 func CreatePool(t *testing.T, client *gophercloud.ServiceClient, subnetID string) (*pools.Pool, error) {

64 poolName := tools.RandomString("TESTACCT-", 8)

86 // specified subnet and pool. An error will be returned if the vip could

87 // not be created.

88 func CreateVIP(t *testing.T, client *gophercloud.ServiceClient, subnetID, poolID string) (*vips.VirtualIP, error) {

89 vipName := tools.RandomString("TESTACCT-", 8)

18 var numObjects = 2

19

20 func TestObjects(t *testing.T) {

21 client, err := clients.NewObjectStorageV1Client()

22 if err != nil {

27 oNames := make([]string, numObjects)

28 for i := 0; i < len(oNames); i++ {

29 oNames[i] = tools.RandomString("test-object-", 8)

30 }

31

32 // Create a container to hold the test objects.

33 cName := tools.RandomString("test-container-", 8)

34 header, err := containers.Create(client, cName, nil).Extract()

35 th.AssertNoErr(t, err)

13 )

14

15 func TestPortsbindingCRUD(t *testing.T) {

16 client, err := clients.NewNetworkV2Client()

17 if err != nil {

46

47 // Update port

48 newPortName := tools.RandomString("TESTACC-", 8)

49 updateOpts := ports.UpdateOpts{

50 Name: newPortName,

16 // CreateVolume will create a volume with a random name and size of 1GB. An

17 // error will be returned if the volume was unable to be created.

18 func CreateVolume(t *testing.T, client *gophercloud.ServiceClient) (*volumes.Volume, error) {

19 if testing.Short() {

20 t.Skip("Skipping test that requires volume creation in short mode.")

21 }

22

23 volumeName := tools.RandomString("ACPTTEST", 16)

24 t.Logf("Attempting to create volume: %s", volumeName)

25

44 // CreateVolumeFromImage will create a volume from with a random name and size of

45 // 1GB. An error will be returned if the volume was unable to be created.

46 func CreateVolumeFromImage(t *testing.T, client *gophercloud.ServiceClient) (*volumes.Volume, error) {

47 if testing.Short() {

48 t.Skip("Skipping test that requires volume creation in short mode.")

18 // CreatePortsbinding will create a port on the specified subnet. An error will be

19 // returned if the port could not be created.

20 func CreatePortsbinding(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID, hostID string) (PortWithBindingExt, error) {

21 portName := tools.RandomString("TESTACC-", 8)

14 // CreateNetwork will create basic network. An error will be returned if the

15 // network could not be created.

16 func CreateNetwork(t *testing.T, client *gophercloud.ServiceClient) (*networks.Network, error) {

17 networkName := tools.RandomString("TESTACC-", 8)

34 // CreatePort will create a port on the specified subnet. An error will be

35 // returned if the port could not be created.

36 func CreatePort(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID string) (*ports.Port, error) {

37 portName := tools.RandomString("TESTACC-", 8)

67 // CreatePortWithNoSecurityGroup will create a port with no security group

68 // attached. An error will be returned if the port could not be created.

69 func CreatePortWithNoSecurityGroup(t *testing.T, client *gophercloud.ServiceClient, networkID, subnetID string) (*ports.Port, error) {

70 portName := tools.RandomString("TESTACC-", 8)

102 // CreateSubnet will create a subnet on the specified Network ID. An error

103 // will be returned if the subnet could not be created.

104 func CreateSubnet(t *testing.T, client *gophercloud.ServiceClient, networkID string) (*subnets.Subnet, error) {

105 subnetName := tools.RandomString("TESTACC-", 8)

12 // CreateRecordSet will create a RecordSet with a random name. An error will

13 // be returned if the zone was unable to be created.

14 func CreateRecordSet(t *testing.T, client *gophercloud.ServiceClient, zone *zones.Zone) (*recordsets.RecordSet, error) {

15 t.Logf("Attempting to create recordset: %s", zone.Name)

16

44 // CreateZone will create a Zone with a random name. An error will

45 // be returned if the zone was unable to be created.

46 func CreateZone(t *testing.T, client *gophercloud.ServiceClient) (*zones.Zone, error) {

47 zoneName := tools.RandomString("ACPTTEST", 8) + ".com."

78 //

79 // This is only for example purposes as it will try to do a zone transfer.

80 func CreateSecondaryZone(t *testing.T, client *gophercloud.ServiceClient) (*zones.Zone, error) {

81 zoneName := tools.RandomString("ACPTTEST", 8) + ".com."

109 // the record set failed to be deleted. This works best when used as a deferred

110 // function.

111 func DeleteRecordSet(t *testing.T, client *gophercloud.ServiceClient, rs *recordsets.RecordSet) {

112 err := recordsets.Delete(client, rs.ZoneID, rs.ID).ExtractErr()

113 if err != nil {

11 // CreateShareNetwork will create a share network with a random name. An

12 // error will be returned if the share network was unable to be created.

13 func CreateShareNetwork(t *testing.T, client *gophercloud.ServiceClient) (*sharenetworks.ShareNetwork, error) {

14 if testing.Short() {

15 t.Skip("Skipping test that requires share network creation in short mode.")

16 }

17

18 shareNetworkName := tools.RandomString("ACPTTEST", 16)

19 t.Logf("Attempting to create share network: %s", shareNetworkName)

20

34 // DeleteShareNetwork will delete a share network. An error will occur if

35 // the share network was unable to be deleted.

36 func DeleteShareNetwork(t *testing.T, client *gophercloud.ServiceClient, shareNetwork *sharenetworks.ShareNetwork) {

37 err := sharenetworks.Delete(client, shareNetwork.ID).ExtractErr()

38 if err != nil {

17 // with a random name. An error will be returned if the snapshot failed to be

18 // created.

19 func CreateSnapshot(t *testing.T, client *gophercloud.ServiceClient, volume *volumes.Volume) (*snapshots.Snapshot, error) {

20 if testing.Short() {

21 t.Skip("Skipping test that requires snapshot creation in short mode.")

22 }

23

24 snapshotName := tools.RandomString("ACPTTEST", 16)

25 t.Logf("Attempting to create snapshot %s based on volume %s", snapshotName, volume.ID)

26

45 // CreateVolume will create a volume with a random name and size of 1GB. An

46 // error will be returned if the volume was unable to be created.

47 func CreateVolume(t *testing.T, client *gophercloud.ServiceClient) (*volumes.Volume, error) {

48 if testing.Short() {

49 t.Skip("Skipping test that requires volume creation in short mode.")

19 // has so many options. An error will be returned if the project was

20 // unable to be created.

21 func CreateProject(t *testing.T, client *gophercloud.ServiceClient, c *projects.CreateOpts) (*projects.Project, error) {

22 name := tools.RandomString("ACPTTEST", 8)

46 // has so many options. An error will be returned if the user was

47 // unable to be created.

48 func CreateUser(t *testing.T, client *gophercloud.ServiceClient, c *users.CreateOpts) (*users.User, error) {

49 name := tools.RandomString("ACPTTEST", 8)

73 // has so many options. An error will be returned if the group was

74 // unable to be created.

75 func CreateGroup(t *testing.T, client *gophercloud.ServiceClient, c *groups.CreateOpts) (*groups.Group, error) {

76 name := tools.RandomString("ACPTTEST", 8)

100 // has many options. An error will be returned if the domain was

101 // unable to be created.

102 func CreateDomain(t *testing.T, client *gophercloud.ServiceClient, c *domains.CreateOpts) (*domains.Domain, error) {

103 name := tools.RandomString("ACPTTEST", 8)

15 )

16

17 func TestLoggingInspectorWithInspection(t *testing.T) {

18 b := bytes.Buffer{}

19 c := Client{}

29 }

30

31 func TestLoggingInspectorWithInspectionEmitsErrors(t *testing.T) {

32 b := bytes.Buffer{}

33 c := Client{}

46 }

47

48 func TestLoggingInspectorWithInspectionRestoresBody(t *testing.T) {

49 b := bytes.Buffer{}

50 c := Client{}

20 )

21

22 func TestGetAllUsers(t *testing.T) {

23 req := httptest.NewRequest(http.MethodGet, "/user/all", nil)

24

36 }

37

38 func TestGetOneUser(t *testing.T) {

39 // 测试正常响应

40 Convey("Given a http request for /user/1", t, func() {

66 }

67

68 func TestAddUser(t *testing.T) {

69 // username 为空的情况

70 Convey("Given a http request for /user/add with empty username", t, func() {

12 )

13

14 func TestPortsList(t *testing.T) {

15 client, err := clients.NewNetworkV2Client()

16 if err != nil {

33 }

34

35 func TestPortsCRUD(t *testing.T) {

36 client, err := clients.NewNetworkV2Client()

37 if err != nil {

67

68 // Update port

69 newPortName := tools.RandomString("TESTACC-", 8)

70 updateOpts := ports.UpdateOpts{

71 Name: newPortName,

14 }

15

16 func TestGetRandomString(t *testing.T) {

17 randomString, err := GetRandomString(4)

18 assert.NoError(t, err)

19 assert.Len(t, randomString, 4)

20 }

21

25 }

26

27 func TestNewProcessUtil(t *testing.T) {

28 procUtil := bagman.NewProcessUtil(&testConfig)

29 defer deleteTestLogs(procUtil.Config)

54 }

55

56 func TestIncrementSucceededAndFailed(t *testing.T) {

57 procUtil := bagman.NewProcessUtil(&testConfig)

58 defer deleteTestLogs(procUtil.Config)

73 }

74

75 func TestMessageIdString(t *testing.T) {

76 procUtil := bagman.NewProcessUtil(&testConfig)

77 defer deleteTestLogs(procUtil.Config)