Tcl Source Code

Check-in [0926e525f7]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Tests for ::http::Write done.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | tip-452
Files: files | file ages | folders
SHA1: 0926e525f72a2eb1d3af52d394acc129deb87571
User & Date: gerald 2017-06-23 20:49:22
Context
2018-09-16
15:09
merge 8.7 check-in: 5dceea74b5 user: jan.nijtmans tags: tip-452
2017-06-23
20:49
Tests for ::http::Write done. check-in: 0926e525f7 user: gerald tags: tip-452
20:08
Added test suites for more of the http package, two procedures left to do test suites for. check-in: 8321eb1dcd user: gerald tags: tip-452
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Changes to tests/http-tip-452.test.

3614
3615
3616
3617
3618
3619
3620
3621
3622











































3623
3624







3625




























































































































































3626



3627

3628
3629

3630













































































































3631
3632
3633
3634
3635
3636
3637
            ::tcltest::testCleanup
        } \
        -result {this%20is%20a%20test}

    ##
    ## Test http::Write
    ##
    ::tcltest::test http-20.1 {http::Write} \
        -setup {











































        } \
        -body {







            list Test Not Yet Implemented




























































































































































        } \



        -cleanup {

            ::tcltest::testCleanup
        } \

        -result {}














































































































    ##
    ## Test http::Event
    ##
    ::tcltest::test http-21.1 {http::Event} \
        -setup {
        } \







|

>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>


>
>
>
>
>
>
>
|
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

>
>
>

>


>
|
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>







3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876
3877
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955
3956
3957
            ::tcltest::testCleanup
        } \
        -result {this%20is%20a%20test}

    ##
    ## Test http::Write
    ##
    ::tcltest::test http-20.1 {http::Write - no error, -query, no excess received, not eof, no progess command} \
        -setup {
            ::tcltest::testSetup {
                ::eof {
                    * {
                        returns {no}
                        code {ok}
                    }
                }
                ::fileevent {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::flush {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::puts {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::read {
                    * {
                        returns {1234567890}
                        code {ok}
                    }
                }
            }
            array set ::httpTest::TestToken {
                posterror {}
                querylength {1024}
                queryoffset {0}
                sock {TestSocket}
                -query {some randome query}
                -queryblocksize {32}
                -querychannel {TestQueryChannel}
                -queryprogress {}
            }
            set ::httpTest::Progress {}
        } \
        -body {
            list [catch {::http::Write ::httpTest::TestToken} results] $results [::tcltest::callCount] $::httpTest::Progress
        } \
        -cleanup {
            unset ::httpTest::TestToken
            ::tcltest::testCleanup
        } \
        -result {0 {} {::eof,count 0 ::fileevent,count 0 ::flush,count 0 ::puts,count 1 ::read,count 0} {}}

    ::tcltest::test http-20.2 {http::Write - error, -query, no excess received, not eof, no progess command} \
        -setup {
            ::tcltest::testSetup {
                ::eof {
                    * {
                        returns {no}
                        code {ok}
                    }
                }
                ::fileevent {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::flush {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::puts {
                    * {
                        returns {TEST ERROR IN PUTS}
                        code {error}
                        errorcoe {HTTP TEST PUTSERROR}
                    }
                }
                ::read {
                    * {
                        returns {1234567890}
                        code {ok}
                    }
                }
            }
            array set ::httpTest::TestToken {
                posterror {}
                querylength {1024}
                queryoffset {0}
                sock {TestSocket}
                -query {some random query}
                -queryblocksize {32}
                -querychannel {TestQueryChannel}
                -queryprogress {}
            }
            set ::httpTest::Progress {}
        } \
        -body {
            list [catch {::http::Write ::httpTest::TestToken} results] $results [::tcltest::callCount] $::httpTest::Progress
        } \
        -cleanup {
            unset ::httpTest::TestToken
            ::tcltest::testCleanup
        } \
        -result {0 {} {::eof,count 0 ::fileevent,count 2 ::flush,count 1 ::puts,count 1 ::read,count 0} {}}

    ::tcltest::test http-20.3 {http::Write - no error, not -query, no excess received, not eof, no progess command} \
        -setup {
            ::tcltest::testSetup {
                ::eof {
                    * {
                        returns {no}
                        code {ok}
                    }
                }
                ::fileevent {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::flush {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::puts {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::read {
                    * {
                        returns {1234567890}
                        code {ok}
                    }
                }
            }
            array set ::httpTest::TestToken {
                posterror {}
                querylength {1024}
                queryoffset {0}
                sock {TestSocket}
                ?-query {}
                -queryblocksize {32}
                -querychannel {TestQueryChannel}
                -queryprogress {}
            }
            set ::httpTest::Progress {}
        } \
        -body {
            list [catch {::http::Write ::httpTest::TestToken} results] $results [::tcltest::callCount] $::httpTest::Progress
        } \
        -cleanup {
            unset ::httpTest::TestToken
            ::tcltest::testCleanup
        } \
        -result {0 {} {::eof,count 1 ::fileevent,count 0 ::flush,count 0 ::puts,count 1 ::read,count 1} {}}

    ::tcltest::test http-20.4 {http::Write - no error, -query, excess received, not eof, no progess command} \
        -setup {
            ::tcltest::testSetup {
                ::eof {
                    * {
                        returns {no}
                        code {ok}
                    }
                }
                ::fileevent {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::flush {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::puts {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::read {
                    * {
                        returns {1234567890}
                        code {ok}
                    }
                }
            }
            array set ::httpTest::TestToken {
                posterror {}
                querylength {1024}
                queryoffset {1000}
                sock {TestSocket}
                -query {some random query}
                -queryblocksize {32}
                -querychannel {TestQueryChannel}
                -queryprogress {}
            }
            set ::httpTest::Progress {}
        } \
        -body {
            list [catch {::http::Write ::httpTest::TestToken} results] $results [::tcltest::callCount] $::httpTest::Progress
        } \
        -cleanup {
            unset ::httpTest::TestToken
            ::tcltest::testCleanup
        } \
        -result {0 {} {::eof,count 0 ::fileevent,count 2 ::flush,count 1 ::puts,count 1 ::read,count 0} {}}

    ::tcltest::test http-20.5 {http::Write - no error, not -query, no excess received, eof, no progess command} \
        -setup {
            ::tcltest::testSetup {
                ::eof {
                    * {
                        returns {yes}
                        code {ok}
                    }
                }
                ::fileevent {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::flush {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::puts {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::read {
                    * {
                        returns {1234567890}
                        code {ok}
                    }
                }
            }
            array set ::httpTest::TestToken {
                posterror {}
                querylength {1024}
                queryoffset {0}
                sock {TestSocket}
                ?-query {some random query}
                -queryblocksize {32}
                -querychannel {TestQueryChannel}
                -queryprogress {}
            }
            set ::httpTest::Progress {}
        } \
        -body {
            list [catch {::http::Write ::httpTest::TestToken} results] $results [::tcltest::callCount] $::httpTest::Progress
        } \
        -cleanup {
            unset ::httpTest::TestToken
            ::tcltest::testCleanup
        } \
        -result {0 {} {::eof,count 1 ::fileevent,count 2 ::flush,count 1 ::puts,count 1 ::read,count 1} {}}

    ::tcltest::test http-20.6 {http::Write - no error, -query, no excess received, not eof, progess command} \
        -setup {
            ::tcltest::testSetup {
                ::eof {
                    * {
                        returns {no}
                        code {ok}
                    }
                }
                ::fileevent {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::flush {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::puts {
                    * {
                        returns {}
                        code {ok}
                    }
                }
                ::read {
                    * {
                        returns {1234567890}
                        code {ok}
                    }
                }
            }
            array set ::httpTest::TestToken {
                posterror {}
                querylength {1024}
                queryoffset {0}
                sock {TestSocket}
                -query {some random query}
                -queryblocksize {32}
                -querychannel {TestQueryChannel}
                -queryprogress {lappend ::httpTest::Progress}
            }
            set ::httpTest::Progress {}
        } \
        -body {
            list [catch {::http::Write ::httpTest::TestToken} results] $results [::tcltest::callCount] $::httpTest::Progress
        } \
        -cleanup {
            unset ::httpTest::TestToken
            ::tcltest::testCleanup
        } \
        -result {0 {::httpTest::TestToken 1024 32} {::eof,count 0 ::fileevent,count 0 ::flush,count 0 ::puts,count 1 ::read,count 0} {::httpTest::TestToken 1024 32}}

    ##
    ## Test http::Event
    ##
    ::tcltest::test http-21.1 {http::Event} \
        -setup {
        } \