github.com/optim-corp/cios-golang-sdk@v0.5.1/model/model_stream_request_wrapper_test.go (about)

     1  package sdkmodel
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	cnv "github.com/fcfcqloow/go-advance/convert"
     8  
     9  	"github.com/optim-corp/cios-golang-sdk/cios"
    10  )
    11  
    12  func TestApiGetStreamRequest_Ascending(t *testing.T) {
    13  	type fields struct {
    14  		ApiService                  *cios.PublishSubscribeApiService
    15  		ChannelId                   string
    16  		PackerFormatParam           *string
    17  		AscendingParam              *bool
    18  		ChannelProtocolVersionParam *int32
    19  		LocationParam               *string
    20  		LocationRangeParam          *string
    21  		TimestampParam              *string
    22  		TimestampRangeParam         *string
    23  		LabelParam                  *string
    24  		OffsetParam                 *int64
    25  		LimitParam                  *int64
    26  		TimeoutParam                *int
    27  		SessionIdParam              *string
    28  		ChannelProtocolIdParam      *string
    29  	}
    30  	type args struct {
    31  		ascending bool
    32  	}
    33  	tests := []struct {
    34  		name   string
    35  		fields fields
    36  		args   args
    37  		want   ApiGetStreamRequest
    38  	}{
    39  		{
    40  			name:   "Test ascending true",
    41  			fields: fields{},
    42  			args:   args{false},
    43  			want: ApiGetStreamRequest{
    44  				AscendingParam: cnv.BoolPtr(false),
    45  			},
    46  		},
    47  		{
    48  			name:   "Test ascending true",
    49  			fields: fields{},
    50  			args:   args{true},
    51  			want: ApiGetStreamRequest{
    52  				AscendingParam: cnv.BoolPtr(true),
    53  			},
    54  		},
    55  	}
    56  	for _, tt := range tests {
    57  		t.Run(tt.name, func(t *testing.T) {
    58  			r := ApiGetStreamRequest{
    59  				ApiService:                  tt.fields.ApiService,
    60  				ChannelId:                   tt.fields.ChannelId,
    61  				PackerFormatParam:           tt.fields.PackerFormatParam,
    62  				AscendingParam:              tt.fields.AscendingParam,
    63  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
    64  				LocationParam:               tt.fields.LocationParam,
    65  				LocationRangeParam:          tt.fields.LocationRangeParam,
    66  				TimestampParam:              tt.fields.TimestampParam,
    67  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
    68  				LabelParam:                  tt.fields.LabelParam,
    69  				OffsetParam:                 tt.fields.OffsetParam,
    70  				LimitParam:                  tt.fields.LimitParam,
    71  				TimeoutParam:                tt.fields.TimeoutParam,
    72  				SessionIdParam:              tt.fields.SessionIdParam,
    73  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
    74  			}
    75  			if got := r.Ascending(tt.args.ascending); !reflect.DeepEqual(got, tt.want) {
    76  				t.Errorf("Ascending() = %v, want %v", got, tt.want)
    77  			}
    78  		})
    79  	}
    80  }
    81  
    82  func TestApiGetStreamRequest_ChannelProtocolId(t *testing.T) {
    83  	type fields struct {
    84  		ApiService                  *cios.PublishSubscribeApiService
    85  		ChannelId                   string
    86  		PackerFormatParam           *string
    87  		AscendingParam              *bool
    88  		ChannelProtocolVersionParam *int32
    89  		LocationParam               *string
    90  		LocationRangeParam          *string
    91  		TimestampParam              *string
    92  		TimestampRangeParam         *string
    93  		LabelParam                  *string
    94  		OffsetParam                 *int64
    95  		LimitParam                  *int64
    96  		TimeoutParam                *int
    97  		SessionIdParam              *string
    98  		ChannelProtocolIdParam      *string
    99  	}
   100  	type args struct {
   101  		channelProtocolId string
   102  	}
   103  	tests := []struct {
   104  		name   string
   105  		fields fields
   106  		args   args
   107  		want   ApiGetStreamRequest
   108  	}{
   109  		{
   110  			name:   "Test channelProtocolId true",
   111  			fields: fields{},
   112  			args:   args{""},
   113  			want: ApiGetStreamRequest{
   114  				ChannelProtocolIdParam: nil,
   115  			},
   116  		},
   117  		{
   118  			name:   "Test channelProtocolId true",
   119  			fields: fields{},
   120  			args:   args{"test"},
   121  			want: ApiGetStreamRequest{
   122  				ChannelProtocolIdParam: cnv.StrPtr("test"),
   123  			},
   124  		},
   125  	}
   126  	for _, tt := range tests {
   127  		t.Run(tt.name, func(t *testing.T) {
   128  			r := ApiGetStreamRequest{
   129  				ApiService:                  tt.fields.ApiService,
   130  				ChannelId:                   tt.fields.ChannelId,
   131  				PackerFormatParam:           tt.fields.PackerFormatParam,
   132  				AscendingParam:              tt.fields.AscendingParam,
   133  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   134  				LocationParam:               tt.fields.LocationParam,
   135  				LocationRangeParam:          tt.fields.LocationRangeParam,
   136  				TimestampParam:              tt.fields.TimestampParam,
   137  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   138  				LabelParam:                  tt.fields.LabelParam,
   139  				OffsetParam:                 tt.fields.OffsetParam,
   140  				LimitParam:                  tt.fields.LimitParam,
   141  				TimeoutParam:                tt.fields.TimeoutParam,
   142  				SessionIdParam:              tt.fields.SessionIdParam,
   143  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   144  			}
   145  			if got := r.ChannelProtocolId(tt.args.channelProtocolId); !reflect.DeepEqual(got, tt.want) {
   146  				t.Errorf("ChannelProtocolId() = %v, want %v", got, tt.want)
   147  			}
   148  		})
   149  	}
   150  }
   151  
   152  func TestApiGetStreamRequest_ChannelProtocolVersion(t *testing.T) {
   153  	type fields struct {
   154  		ApiService                  *cios.PublishSubscribeApiService
   155  		ChannelId                   string
   156  		PackerFormatParam           *string
   157  		AscendingParam              *bool
   158  		ChannelProtocolVersionParam *int32
   159  		LocationParam               *string
   160  		LocationRangeParam          *string
   161  		TimestampParam              *string
   162  		TimestampRangeParam         *string
   163  		LabelParam                  *string
   164  		OffsetParam                 *int64
   165  		LimitParam                  *int64
   166  		TimeoutParam                *int
   167  		SessionIdParam              *string
   168  		ChannelProtocolIdParam      *string
   169  	}
   170  	type args struct {
   171  		channelProtocolVersion int32
   172  	}
   173  	tests := []struct {
   174  		name   string
   175  		fields fields
   176  		args   args
   177  		want   ApiGetStreamRequest
   178  	}{
   179  		{
   180  			name:   "Test channelProtocolVersion true",
   181  			fields: fields{},
   182  			args:   args{1},
   183  			want: ApiGetStreamRequest{
   184  				ChannelProtocolVersionParam: cnv.Int32Ptr(1),
   185  			},
   186  		},
   187  		{
   188  			name:   "Test channelProtocolVersion true",
   189  			fields: fields{},
   190  			args:   args{12},
   191  			want: ApiGetStreamRequest{
   192  				ChannelProtocolVersionParam: cnv.Int32Ptr(12),
   193  			},
   194  		},
   195  	}
   196  	for _, tt := range tests {
   197  		t.Run(tt.name, func(t *testing.T) {
   198  			r := ApiGetStreamRequest{
   199  				ApiService:                  tt.fields.ApiService,
   200  				ChannelId:                   tt.fields.ChannelId,
   201  				PackerFormatParam:           tt.fields.PackerFormatParam,
   202  				AscendingParam:              tt.fields.AscendingParam,
   203  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   204  				LocationParam:               tt.fields.LocationParam,
   205  				LocationRangeParam:          tt.fields.LocationRangeParam,
   206  				TimestampParam:              tt.fields.TimestampParam,
   207  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   208  				LabelParam:                  tt.fields.LabelParam,
   209  				OffsetParam:                 tt.fields.OffsetParam,
   210  				LimitParam:                  tt.fields.LimitParam,
   211  				TimeoutParam:                tt.fields.TimeoutParam,
   212  				SessionIdParam:              tt.fields.SessionIdParam,
   213  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   214  			}
   215  			if got := r.ChannelProtocolVersion(tt.args.channelProtocolVersion); !reflect.DeepEqual(got, tt.want) {
   216  				t.Errorf("ChannelProtocolVersion() = %v, want %v", got, tt.want)
   217  			}
   218  		})
   219  	}
   220  }
   221  
   222  func TestApiGetStreamRequest_Label(t *testing.T) {
   223  	type fields struct {
   224  		ApiService                  *cios.PublishSubscribeApiService
   225  		ChannelId                   string
   226  		PackerFormatParam           *string
   227  		AscendingParam              *bool
   228  		ChannelProtocolVersionParam *int32
   229  		LocationParam               *string
   230  		LocationRangeParam          *string
   231  		TimestampParam              *string
   232  		TimestampRangeParam         *string
   233  		LabelParam                  *string
   234  		OffsetParam                 *int64
   235  		LimitParam                  *int64
   236  		TimeoutParam                *int
   237  		SessionIdParam              *string
   238  		ChannelProtocolIdParam      *string
   239  	}
   240  	type args struct {
   241  		label string
   242  	}
   243  	tests := []struct {
   244  		name   string
   245  		fields fields
   246  		args   args
   247  		want   ApiGetStreamRequest
   248  	}{
   249  		{
   250  			name:   "Test label true",
   251  			fields: fields{},
   252  			args:   args{""},
   253  			want: ApiGetStreamRequest{
   254  				LabelParam: nil,
   255  			},
   256  		},
   257  		{
   258  			name:   "Test label true",
   259  			fields: fields{},
   260  			args:   args{"test"},
   261  			want: ApiGetStreamRequest{
   262  				LabelParam: cnv.StrPtr("test"),
   263  			},
   264  		},
   265  	}
   266  	for _, tt := range tests {
   267  		t.Run(tt.name, func(t *testing.T) {
   268  			r := ApiGetStreamRequest{
   269  				ApiService:                  tt.fields.ApiService,
   270  				ChannelId:                   tt.fields.ChannelId,
   271  				PackerFormatParam:           tt.fields.PackerFormatParam,
   272  				AscendingParam:              tt.fields.AscendingParam,
   273  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   274  				LocationParam:               tt.fields.LocationParam,
   275  				LocationRangeParam:          tt.fields.LocationRangeParam,
   276  				TimestampParam:              tt.fields.TimestampParam,
   277  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   278  				LabelParam:                  tt.fields.LabelParam,
   279  				OffsetParam:                 tt.fields.OffsetParam,
   280  				LimitParam:                  tt.fields.LimitParam,
   281  				TimeoutParam:                tt.fields.TimeoutParam,
   282  				SessionIdParam:              tt.fields.SessionIdParam,
   283  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   284  			}
   285  			if got := r.Label(tt.args.label); !reflect.DeepEqual(got, tt.want) {
   286  				t.Errorf("Label() = %v, want %v", got, tt.want)
   287  			}
   288  		})
   289  	}
   290  }
   291  
   292  func TestApiGetStreamRequest_Limit(t *testing.T) {
   293  	type fields struct {
   294  		ApiService                  *cios.PublishSubscribeApiService
   295  		ChannelId                   string
   296  		PackerFormatParam           *string
   297  		AscendingParam              *bool
   298  		ChannelProtocolVersionParam *int32
   299  		LocationParam               *string
   300  		LocationRangeParam          *string
   301  		TimestampParam              *string
   302  		TimestampRangeParam         *string
   303  		LabelParam                  *string
   304  		OffsetParam                 *int64
   305  		LimitParam                  *int64
   306  		TimeoutParam                *int
   307  		SessionIdParam              *string
   308  		ChannelProtocolIdParam      *string
   309  	}
   310  	type args struct {
   311  		limit int64
   312  	}
   313  	tests := []struct {
   314  		name   string
   315  		fields fields
   316  		args   args
   317  		want   ApiGetStreamRequest
   318  	}{
   319  		{
   320  			name:   "Test limit true",
   321  			fields: fields{},
   322  			args:   args{21},
   323  			want: ApiGetStreamRequest{
   324  				LimitParam: cnv.Int64Ptr(21),
   325  			},
   326  		},
   327  		{
   328  			name:   "Test limit true",
   329  			fields: fields{},
   330  			args:   args{0},
   331  			want: ApiGetStreamRequest{
   332  				LimitParam: cnv.Int64Ptr(0),
   333  			},
   334  		},
   335  	}
   336  	for _, tt := range tests {
   337  		t.Run(tt.name, func(t *testing.T) {
   338  			r := ApiGetStreamRequest{
   339  				ApiService:                  tt.fields.ApiService,
   340  				ChannelId:                   tt.fields.ChannelId,
   341  				PackerFormatParam:           tt.fields.PackerFormatParam,
   342  				AscendingParam:              tt.fields.AscendingParam,
   343  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   344  				LocationParam:               tt.fields.LocationParam,
   345  				LocationRangeParam:          tt.fields.LocationRangeParam,
   346  				TimestampParam:              tt.fields.TimestampParam,
   347  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   348  				LabelParam:                  tt.fields.LabelParam,
   349  				OffsetParam:                 tt.fields.OffsetParam,
   350  				LimitParam:                  tt.fields.LimitParam,
   351  				TimeoutParam:                tt.fields.TimeoutParam,
   352  				SessionIdParam:              tt.fields.SessionIdParam,
   353  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   354  			}
   355  			if got := r.Limit(tt.args.limit); !reflect.DeepEqual(got, tt.want) {
   356  				t.Errorf("Limit() = %v, want %v", got, tt.want)
   357  			}
   358  		})
   359  	}
   360  }
   361  
   362  func TestApiGetStreamRequest_Location(t *testing.T) {
   363  	type fields struct {
   364  		ApiService                  *cios.PublishSubscribeApiService
   365  		ChannelId                   string
   366  		PackerFormatParam           *string
   367  		AscendingParam              *bool
   368  		ChannelProtocolVersionParam *int32
   369  		LocationParam               *string
   370  		LocationRangeParam          *string
   371  		TimestampParam              *string
   372  		TimestampRangeParam         *string
   373  		LabelParam                  *string
   374  		OffsetParam                 *int64
   375  		LimitParam                  *int64
   376  		TimeoutParam                *int
   377  		SessionIdParam              *string
   378  		ChannelProtocolIdParam      *string
   379  	}
   380  	type args struct {
   381  		location string
   382  	}
   383  	tests := []struct {
   384  		name   string
   385  		fields fields
   386  		args   args
   387  		want   ApiGetStreamRequest
   388  	}{
   389  		{
   390  			name:   "Test location true",
   391  			fields: fields{},
   392  			args:   args{""},
   393  			want: ApiGetStreamRequest{
   394  				LocationParam: nil,
   395  			},
   396  		},
   397  		{
   398  			name:   "Test location true",
   399  			fields: fields{},
   400  			args:   args{"test"},
   401  			want: ApiGetStreamRequest{
   402  				LocationParam: cnv.StrPtr("test"),
   403  			},
   404  		},
   405  	}
   406  	for _, tt := range tests {
   407  		t.Run(tt.name, func(t *testing.T) {
   408  			r := ApiGetStreamRequest{
   409  				ApiService:                  tt.fields.ApiService,
   410  				ChannelId:                   tt.fields.ChannelId,
   411  				PackerFormatParam:           tt.fields.PackerFormatParam,
   412  				AscendingParam:              tt.fields.AscendingParam,
   413  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   414  				LocationParam:               tt.fields.LocationParam,
   415  				LocationRangeParam:          tt.fields.LocationRangeParam,
   416  				TimestampParam:              tt.fields.TimestampParam,
   417  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   418  				LabelParam:                  tt.fields.LabelParam,
   419  				OffsetParam:                 tt.fields.OffsetParam,
   420  				LimitParam:                  tt.fields.LimitParam,
   421  				TimeoutParam:                tt.fields.TimeoutParam,
   422  				SessionIdParam:              tt.fields.SessionIdParam,
   423  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   424  			}
   425  			if got := r.Location(tt.args.location); !reflect.DeepEqual(got, tt.want) {
   426  				t.Errorf("Location() = %v, want %v", got, tt.want)
   427  			}
   428  		})
   429  	}
   430  }
   431  
   432  func TestApiGetStreamRequest_LocationRange(t *testing.T) {
   433  	type fields struct {
   434  		ApiService                  *cios.PublishSubscribeApiService
   435  		ChannelId                   string
   436  		PackerFormatParam           *string
   437  		AscendingParam              *bool
   438  		ChannelProtocolVersionParam *int32
   439  		LocationParam               *string
   440  		LocationRangeParam          *string
   441  		TimestampParam              *string
   442  		TimestampRangeParam         *string
   443  		LabelParam                  *string
   444  		OffsetParam                 *int64
   445  		LimitParam                  *int64
   446  		TimeoutParam                *int
   447  		SessionIdParam              *string
   448  		ChannelProtocolIdParam      *string
   449  	}
   450  	type args struct {
   451  		locationRange string
   452  	}
   453  	tests := []struct {
   454  		name   string
   455  		fields fields
   456  		args   args
   457  		want   ApiGetStreamRequest
   458  	}{
   459  		{
   460  			name:   "Test locationRange true",
   461  			fields: fields{},
   462  			args:   args{""},
   463  			want: ApiGetStreamRequest{
   464  				LocationRangeParam: nil,
   465  			},
   466  		},
   467  		{
   468  			name:   "Test locationRange true",
   469  			fields: fields{},
   470  			args:   args{"test"},
   471  			want: ApiGetStreamRequest{
   472  				LocationRangeParam: cnv.StrPtr("test"),
   473  			},
   474  		},
   475  	}
   476  	for _, tt := range tests {
   477  		t.Run(tt.name, func(t *testing.T) {
   478  			r := ApiGetStreamRequest{
   479  				ApiService:                  tt.fields.ApiService,
   480  				ChannelId:                   tt.fields.ChannelId,
   481  				PackerFormatParam:           tt.fields.PackerFormatParam,
   482  				AscendingParam:              tt.fields.AscendingParam,
   483  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   484  				LocationParam:               tt.fields.LocationParam,
   485  				LocationRangeParam:          tt.fields.LocationRangeParam,
   486  				TimestampParam:              tt.fields.TimestampParam,
   487  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   488  				LabelParam:                  tt.fields.LabelParam,
   489  				OffsetParam:                 tt.fields.OffsetParam,
   490  				LimitParam:                  tt.fields.LimitParam,
   491  				TimeoutParam:                tt.fields.TimeoutParam,
   492  				SessionIdParam:              tt.fields.SessionIdParam,
   493  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   494  			}
   495  			if got := r.LocationRange(tt.args.locationRange); !reflect.DeepEqual(got, tt.want) {
   496  				t.Errorf("LocationRange() = %v, want %v", got, tt.want)
   497  			}
   498  		})
   499  	}
   500  }
   501  
   502  func TestApiGetStreamRequest_Offset(t *testing.T) {
   503  	type fields struct {
   504  		ApiService                  *cios.PublishSubscribeApiService
   505  		ChannelId                   string
   506  		PackerFormatParam           *string
   507  		AscendingParam              *bool
   508  		ChannelProtocolVersionParam *int32
   509  		LocationParam               *string
   510  		LocationRangeParam          *string
   511  		TimestampParam              *string
   512  		TimestampRangeParam         *string
   513  		LabelParam                  *string
   514  		OffsetParam                 *int64
   515  		LimitParam                  *int64
   516  		TimeoutParam                *int
   517  		SessionIdParam              *string
   518  		ChannelProtocolIdParam      *string
   519  	}
   520  	type args struct {
   521  		offset int64
   522  	}
   523  	tests := []struct {
   524  		name   string
   525  		fields fields
   526  		args   args
   527  		want   ApiGetStreamRequest
   528  	}{
   529  		{
   530  			name:   "Test offset true",
   531  			fields: fields{},
   532  			args:   args{0},
   533  			want: ApiGetStreamRequest{
   534  				OffsetParam: cnv.Int64Ptr(0),
   535  			},
   536  		},
   537  		{
   538  			name:   "Test offset true",
   539  			fields: fields{},
   540  			args:   args{21},
   541  			want: ApiGetStreamRequest{
   542  				OffsetParam: cnv.Int64Ptr(21),
   543  			},
   544  		},
   545  	}
   546  	for _, tt := range tests {
   547  		t.Run(tt.name, func(t *testing.T) {
   548  			r := ApiGetStreamRequest{
   549  				ApiService:                  tt.fields.ApiService,
   550  				ChannelId:                   tt.fields.ChannelId,
   551  				PackerFormatParam:           tt.fields.PackerFormatParam,
   552  				AscendingParam:              tt.fields.AscendingParam,
   553  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   554  				LocationParam:               tt.fields.LocationParam,
   555  				LocationRangeParam:          tt.fields.LocationRangeParam,
   556  				TimestampParam:              tt.fields.TimestampParam,
   557  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   558  				LabelParam:                  tt.fields.LabelParam,
   559  				OffsetParam:                 tt.fields.OffsetParam,
   560  				LimitParam:                  tt.fields.LimitParam,
   561  				TimeoutParam:                tt.fields.TimeoutParam,
   562  				SessionIdParam:              tt.fields.SessionIdParam,
   563  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   564  			}
   565  			if got := r.Offset(tt.args.offset); !reflect.DeepEqual(got, tt.want) {
   566  				t.Errorf("Offset() = %v, want %v", got, tt.want)
   567  			}
   568  		})
   569  	}
   570  }
   571  
   572  func TestApiGetStreamRequest_PackerFormat(t *testing.T) {
   573  	type fields struct {
   574  		ApiService                  *cios.PublishSubscribeApiService
   575  		ChannelId                   string
   576  		PackerFormatParam           *string
   577  		AscendingParam              *bool
   578  		ChannelProtocolVersionParam *int32
   579  		LocationParam               *string
   580  		LocationRangeParam          *string
   581  		TimestampParam              *string
   582  		TimestampRangeParam         *string
   583  		LabelParam                  *string
   584  		OffsetParam                 *int64
   585  		LimitParam                  *int64
   586  		TimeoutParam                *int
   587  		SessionIdParam              *string
   588  		ChannelProtocolIdParam      *string
   589  	}
   590  	type args struct {
   591  		packerPacker string
   592  	}
   593  	tests := []struct {
   594  		name   string
   595  		fields fields
   596  		args   args
   597  		want   ApiGetStreamRequest
   598  	}{
   599  		{
   600  			name:   "Test packerPacker true",
   601  			fields: fields{},
   602  			args:   args{""},
   603  			want: ApiGetStreamRequest{
   604  				PackerFormatParam: nil,
   605  			},
   606  		},
   607  		{
   608  			name:   "Test packerPacker true",
   609  			fields: fields{},
   610  			args:   args{"test"},
   611  			want: ApiGetStreamRequest{
   612  				PackerFormatParam: cnv.StrPtr("test"),
   613  			},
   614  		},
   615  	}
   616  	for _, tt := range tests {
   617  		t.Run(tt.name, func(t *testing.T) {
   618  			r := ApiGetStreamRequest{
   619  				ApiService:                  tt.fields.ApiService,
   620  				ChannelId:                   tt.fields.ChannelId,
   621  				PackerFormatParam:           tt.fields.PackerFormatParam,
   622  				AscendingParam:              tt.fields.AscendingParam,
   623  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   624  				LocationParam:               tt.fields.LocationParam,
   625  				LocationRangeParam:          tt.fields.LocationRangeParam,
   626  				TimestampParam:              tt.fields.TimestampParam,
   627  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   628  				LabelParam:                  tt.fields.LabelParam,
   629  				OffsetParam:                 tt.fields.OffsetParam,
   630  				LimitParam:                  tt.fields.LimitParam,
   631  				TimeoutParam:                tt.fields.TimeoutParam,
   632  				SessionIdParam:              tt.fields.SessionIdParam,
   633  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   634  			}
   635  			if got := r.PackerFormat(tt.args.packerPacker); !reflect.DeepEqual(got, tt.want) {
   636  				t.Errorf("PackerFormat() = %v, want %v", got, tt.want)
   637  			}
   638  		})
   639  	}
   640  }
   641  
   642  func TestApiGetStreamRequest_SessionID(t *testing.T) {
   643  	type fields struct {
   644  		ApiService                  *cios.PublishSubscribeApiService
   645  		ChannelId                   string
   646  		PackerFormatParam           *string
   647  		AscendingParam              *bool
   648  		ChannelProtocolVersionParam *int32
   649  		LocationParam               *string
   650  		LocationRangeParam          *string
   651  		TimestampParam              *string
   652  		TimestampRangeParam         *string
   653  		LabelParam                  *string
   654  		OffsetParam                 *int64
   655  		LimitParam                  *int64
   656  		TimeoutParam                *int
   657  		SessionIdParam              *string
   658  		ChannelProtocolIdParam      *string
   659  	}
   660  	type args struct {
   661  		sessionID string
   662  	}
   663  	tests := []struct {
   664  		name   string
   665  		fields fields
   666  		args   args
   667  		want   ApiGetStreamRequest
   668  	}{
   669  		{
   670  			name:   "Test sessionID true",
   671  			fields: fields{},
   672  			args:   args{""},
   673  			want: ApiGetStreamRequest{
   674  				SessionIdParam: nil,
   675  			},
   676  		},
   677  		{
   678  			name:   "Test sessionID true",
   679  			fields: fields{},
   680  			args:   args{"test"},
   681  			want: ApiGetStreamRequest{
   682  				SessionIdParam: cnv.StrPtr("test"),
   683  			},
   684  		},
   685  	}
   686  	for _, tt := range tests {
   687  		t.Run(tt.name, func(t *testing.T) {
   688  			r := ApiGetStreamRequest{
   689  				ApiService:                  tt.fields.ApiService,
   690  				ChannelId:                   tt.fields.ChannelId,
   691  				PackerFormatParam:           tt.fields.PackerFormatParam,
   692  				AscendingParam:              tt.fields.AscendingParam,
   693  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   694  				LocationParam:               tt.fields.LocationParam,
   695  				LocationRangeParam:          tt.fields.LocationRangeParam,
   696  				TimestampParam:              tt.fields.TimestampParam,
   697  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   698  				LabelParam:                  tt.fields.LabelParam,
   699  				OffsetParam:                 tt.fields.OffsetParam,
   700  				LimitParam:                  tt.fields.LimitParam,
   701  				TimeoutParam:                tt.fields.TimeoutParam,
   702  				SessionIdParam:              tt.fields.SessionIdParam,
   703  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   704  			}
   705  			if got := r.SessionID(tt.args.sessionID); !reflect.DeepEqual(got, tt.want) {
   706  				t.Errorf("SessionID() = %v, want %v", got, tt.want)
   707  			}
   708  		})
   709  	}
   710  }
   711  
   712  func TestApiGetStreamRequest_Timeout(t *testing.T) {
   713  	type fields struct {
   714  		ApiService                  *cios.PublishSubscribeApiService
   715  		ChannelId                   string
   716  		PackerFormatParam           *string
   717  		AscendingParam              *bool
   718  		ChannelProtocolVersionParam *int32
   719  		LocationParam               *string
   720  		LocationRangeParam          *string
   721  		TimestampParam              *string
   722  		TimestampRangeParam         *string
   723  		LabelParam                  *string
   724  		OffsetParam                 *int64
   725  		LimitParam                  *int64
   726  		TimeoutParam                *int
   727  		SessionIdParam              *string
   728  		ChannelProtocolIdParam      *string
   729  	}
   730  	type args struct {
   731  		timeout int
   732  	}
   733  	tests := []struct {
   734  		name   string
   735  		fields fields
   736  		args   args
   737  		want   ApiGetStreamRequest
   738  	}{
   739  		{
   740  			name:   "Test timeout true",
   741  			fields: fields{},
   742  			args:   args{0},
   743  			want: ApiGetStreamRequest{
   744  				TimeoutParam: cnv.IntPtr(0),
   745  			},
   746  		},
   747  		{
   748  			name:   "Test timeout true",
   749  			fields: fields{},
   750  			args:   args{12},
   751  			want: ApiGetStreamRequest{
   752  				TimeoutParam: cnv.IntPtr(12),
   753  			},
   754  		},
   755  	}
   756  	for _, tt := range tests {
   757  		t.Run(tt.name, func(t *testing.T) {
   758  			r := ApiGetStreamRequest{
   759  				ApiService:                  tt.fields.ApiService,
   760  				ChannelId:                   tt.fields.ChannelId,
   761  				PackerFormatParam:           tt.fields.PackerFormatParam,
   762  				AscendingParam:              tt.fields.AscendingParam,
   763  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   764  				LocationParam:               tt.fields.LocationParam,
   765  				LocationRangeParam:          tt.fields.LocationRangeParam,
   766  				TimestampParam:              tt.fields.TimestampParam,
   767  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   768  				LabelParam:                  tt.fields.LabelParam,
   769  				OffsetParam:                 tt.fields.OffsetParam,
   770  				LimitParam:                  tt.fields.LimitParam,
   771  				TimeoutParam:                tt.fields.TimeoutParam,
   772  				SessionIdParam:              tt.fields.SessionIdParam,
   773  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   774  			}
   775  			if got := r.Timeout(tt.args.timeout); !reflect.DeepEqual(got, tt.want) {
   776  				t.Errorf("Timeout() = %v, want %v", got, tt.want)
   777  			}
   778  		})
   779  	}
   780  }
   781  
   782  func TestApiGetStreamRequest_Timestamp(t *testing.T) {
   783  	type fields struct {
   784  		ApiService                  *cios.PublishSubscribeApiService
   785  		ChannelId                   string
   786  		PackerFormatParam           *string
   787  		AscendingParam              *bool
   788  		ChannelProtocolVersionParam *int32
   789  		LocationParam               *string
   790  		LocationRangeParam          *string
   791  		TimestampParam              *string
   792  		TimestampRangeParam         *string
   793  		LabelParam                  *string
   794  		OffsetParam                 *int64
   795  		LimitParam                  *int64
   796  		TimeoutParam                *int
   797  		SessionIdParam              *string
   798  		ChannelProtocolIdParam      *string
   799  	}
   800  	type args struct {
   801  		timestamp string
   802  	}
   803  	tests := []struct {
   804  		name   string
   805  		fields fields
   806  		args   args
   807  		want   ApiGetStreamRequest
   808  	}{
   809  		{
   810  			name:   "Test timestamp true",
   811  			fields: fields{},
   812  			args:   args{""},
   813  			want: ApiGetStreamRequest{
   814  				TimestampParam: nil,
   815  			},
   816  		},
   817  		{
   818  			name:   "Test timestamp true",
   819  			fields: fields{},
   820  			args:   args{"test"},
   821  			want: ApiGetStreamRequest{
   822  				TimestampParam: cnv.StrPtr("test"),
   823  			},
   824  		},
   825  	}
   826  	for _, tt := range tests {
   827  		t.Run(tt.name, func(t *testing.T) {
   828  			r := ApiGetStreamRequest{
   829  				ApiService:                  tt.fields.ApiService,
   830  				ChannelId:                   tt.fields.ChannelId,
   831  				PackerFormatParam:           tt.fields.PackerFormatParam,
   832  				AscendingParam:              tt.fields.AscendingParam,
   833  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   834  				LocationParam:               tt.fields.LocationParam,
   835  				LocationRangeParam:          tt.fields.LocationRangeParam,
   836  				TimestampParam:              tt.fields.TimestampParam,
   837  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   838  				LabelParam:                  tt.fields.LabelParam,
   839  				OffsetParam:                 tt.fields.OffsetParam,
   840  				LimitParam:                  tt.fields.LimitParam,
   841  				TimeoutParam:                tt.fields.TimeoutParam,
   842  				SessionIdParam:              tt.fields.SessionIdParam,
   843  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   844  			}
   845  			if got := r.Timestamp(tt.args.timestamp); !reflect.DeepEqual(got, tt.want) {
   846  				t.Errorf("Timestamp() = %v, want %v", got, tt.want)
   847  			}
   848  		})
   849  	}
   850  }
   851  
   852  func TestApiGetStreamRequest_TimestampRange(t *testing.T) {
   853  	type fields struct {
   854  		ApiService                  *cios.PublishSubscribeApiService
   855  		ChannelId                   string
   856  		PackerFormatParam           *string
   857  		AscendingParam              *bool
   858  		ChannelProtocolVersionParam *int32
   859  		LocationParam               *string
   860  		LocationRangeParam          *string
   861  		TimestampParam              *string
   862  		TimestampRangeParam         *string
   863  		LabelParam                  *string
   864  		OffsetParam                 *int64
   865  		LimitParam                  *int64
   866  		TimeoutParam                *int
   867  		SessionIdParam              *string
   868  		ChannelProtocolIdParam      *string
   869  	}
   870  	type args struct {
   871  		timestampRange string
   872  	}
   873  	tests := []struct {
   874  		name   string
   875  		fields fields
   876  		args   args
   877  		want   ApiGetStreamRequest
   878  	}{
   879  		{
   880  			name:   "Test timestampRange true",
   881  			fields: fields{},
   882  			args:   args{""},
   883  			want: ApiGetStreamRequest{
   884  				TimestampRangeParam: nil,
   885  			},
   886  		},
   887  		{
   888  			name:   "Test timestampRange true",
   889  			fields: fields{},
   890  			args:   args{"test"},
   891  			want: ApiGetStreamRequest{
   892  				TimestampRangeParam: cnv.StrPtr("test"),
   893  			},
   894  		},
   895  	}
   896  	for _, tt := range tests {
   897  		t.Run(tt.name, func(t *testing.T) {
   898  			r := ApiGetStreamRequest{
   899  				ApiService:                  tt.fields.ApiService,
   900  				ChannelId:                   tt.fields.ChannelId,
   901  				PackerFormatParam:           tt.fields.PackerFormatParam,
   902  				AscendingParam:              tt.fields.AscendingParam,
   903  				ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam,
   904  				LocationParam:               tt.fields.LocationParam,
   905  				LocationRangeParam:          tt.fields.LocationRangeParam,
   906  				TimestampParam:              tt.fields.TimestampParam,
   907  				TimestampRangeParam:         tt.fields.TimestampRangeParam,
   908  				LabelParam:                  tt.fields.LabelParam,
   909  				OffsetParam:                 tt.fields.OffsetParam,
   910  				LimitParam:                  tt.fields.LimitParam,
   911  				TimeoutParam:                tt.fields.TimeoutParam,
   912  				SessionIdParam:              tt.fields.SessionIdParam,
   913  				ChannelProtocolIdParam:      tt.fields.ChannelProtocolIdParam,
   914  			}
   915  			if got := r.TimestampRange(tt.args.timestampRange); !reflect.DeepEqual(got, tt.want) {
   916  				t.Errorf("TimestampRange() = %v, want %v", got, tt.want)
   917  			}
   918  		})
   919  	}
   920  }