~xnox/ubuntu/vivid/upstart/fix-rotate-logs

« back to all changes in this revision

Viewing changes to init/tests/test_environ.c

  • Committer: James Hunt
  • Date: 2014-07-17 13:14:00 UTC
  • mfrom: (1436.2.7)
  • Revision ID: james.hunt@ubuntu.com-20140717131400-airqibye4266cazq
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
618
618
void
619
619
test_remove (void)
620
620
{
621
 
        char   **env = NULL, **ret;
622
 
        size_t   len = 0;
 
621
        char    **env = NULL;
 
622
        char     *removed = NULL;
 
623
        char    **ret = NULL;
 
624
        size_t    len = 0;
623
625
 
624
626
        TEST_FUNCTION ("environ_remove");
625
627
 
688
690
                        TEST_ALLOC_PARENT (env[0], env);
689
691
                        TEST_ALLOC_SIZE (env[0], 8);
690
692
                        TEST_EQ_STR (env[0], "FOO=BAR");
 
693
                        removed = env[0];
 
694
                        TEST_FREE_TAG (removed);
 
695
 
691
696
                        TEST_EQ_P (env[1], NULL);
692
697
                }
693
698
 
695
700
 
696
701
                if (test_alloc_failed) {
697
702
                        TEST_EQ_P (ret, NULL);
698
 
 
699
 
                        TEST_EQ (len, 1);
700
 
 
701
 
                        TEST_ALLOC_PARENT (env[0], env);
702
 
                        TEST_ALLOC_SIZE (env[0], 8);
703
 
 
704
 
                        TEST_NE_P (env[0], NULL);
705
 
                        TEST_EQ_STR (env[0], "FOO=BAR");
706
 
 
707
 
                        TEST_EQ_P (env[1], NULL);
708
 
 
709
703
                        nih_free (env);
710
704
                        continue;
711
705
                }
713
707
                TEST_NE_P (ret, NULL);
714
708
                TEST_EQ (len, 0);
715
709
                TEST_EQ_P (env[0], NULL);
 
710
                TEST_FREE (removed);
716
711
 
717
712
                nih_free (env);
718
713
        }
730
725
                        TEST_ALLOC_PARENT (env[0], env);
731
726
                        TEST_ALLOC_SIZE (env[0], 8);
732
727
                        TEST_EQ_STR (env[0], "FOO=BAR");
 
728
                        removed = env[0];
 
729
                        TEST_FREE_TAG (removed);
 
730
 
733
731
                        TEST_EQ_P (env[1], NULL);
734
732
                }
735
733
 
737
735
 
738
736
                if (test_alloc_failed) {
739
737
                        TEST_EQ_P (ret, NULL);
740
 
 
741
 
                        TEST_EQ (len, 1);
742
 
 
743
 
                        TEST_ALLOC_PARENT (env[0], env);
744
 
                        TEST_ALLOC_SIZE (env[0], 8);
745
 
 
746
 
                        TEST_NE_P (env[0], NULL);
747
 
                        TEST_EQ_STR (env[0], "FOO=BAR");
748
 
 
749
 
                        TEST_EQ_P (env[1], NULL);
750
 
 
751
738
                        nih_free (env);
752
739
                        continue;
753
740
                }
755
742
                TEST_NE_P (ret, NULL);
756
743
                TEST_EQ (len, 0);
757
744
                TEST_EQ_P (env[0], NULL);
 
745
                TEST_FREE (removed);
758
746
 
759
747
                nih_free (env);
760
748
        }
781
769
                        TEST_ALLOC_PARENT (env[0], env);
782
770
                        TEST_ALLOC_SIZE (env[0], 8);
783
771
                        TEST_EQ_STR (env[0], "FOO=BAR");
 
772
                        removed = env[0];
 
773
                        TEST_FREE_TAG (removed);
784
774
 
785
775
                        TEST_ALLOC_PARENT (env[1], env);
786
776
                        TEST_ALLOC_SIZE (env[1], 8);
794
784
 
795
785
                if (test_alloc_failed) {
796
786
                        TEST_EQ_P (ret, NULL);
797
 
 
798
 
                        TEST_EQ (len, 2);
799
 
                        TEST_ALLOC_PARENT (env[0], env);
800
 
                        TEST_ALLOC_SIZE (env[0], 8);
801
 
                        TEST_EQ_STR (env[0], "FOO=BAR");
802
 
 
803
 
                        TEST_ALLOC_PARENT (env[1], env);
804
 
                        TEST_ALLOC_SIZE (env[1], 8);
805
 
                        TEST_EQ_STR (env[1], "BAZ=QUX");
806
 
 
807
 
                        TEST_EQ_P (env[2], NULL);
808
 
 
809
787
                        nih_free (env);
810
788
                        continue;
811
789
                }
816
794
                TEST_ALLOC_PARENT (env[0], env);
817
795
                TEST_ALLOC_SIZE (env[0], 8);
818
796
                TEST_EQ_STR (env[0], "BAZ=QUX");
 
797
                TEST_FREE (removed);
819
798
 
820
799
                TEST_EQ_P (env[1], NULL);
821
800
 
852
831
                        TEST_ALLOC_PARENT (env[0], env);
853
832
                        TEST_ALLOC_SIZE (env[0], 8);
854
833
                        TEST_EQ_STR (env[0], "UPSTART_TEST_VARIABLE=foo");
 
834
                        removed = env[0];
 
835
                        TEST_FREE_TAG (removed);
855
836
 
856
837
                        TEST_ALLOC_PARENT (env[1], env);
857
838
                        TEST_ALLOC_SIZE (env[1], 8);
865
846
 
866
847
                if (test_alloc_failed) {
867
848
                        TEST_EQ_P (ret, NULL);
868
 
 
869
 
                        TEST_EQ (len, 2);
870
 
                        TEST_ALLOC_PARENT (env[0], env);
871
 
                        TEST_ALLOC_SIZE (env[0], 8);
872
 
                        TEST_EQ_STR (env[0], "UPSTART_TEST_VARIABLE=foo");
873
 
 
874
 
                        TEST_ALLOC_PARENT (env[1], env);
875
 
                        TEST_ALLOC_SIZE (env[1], 8);
876
 
                        TEST_EQ_STR (env[1], "BAZ=QUX");
877
 
 
878
 
                        TEST_EQ_P (env[2], NULL);
879
 
 
880
849
                        nih_free (env);
881
850
                        continue;
882
851
                }
887
856
                TEST_ALLOC_PARENT (env[0], env);
888
857
                TEST_ALLOC_SIZE (env[0], 8);
889
858
                TEST_EQ_STR (env[0], "BAZ=QUX");
 
859
                TEST_FREE (removed);
890
860
 
891
861
                TEST_EQ_P (env[1], NULL);
892
862
 
921
891
                        TEST_ALLOC_PARENT (env[1], env);
922
892
                        TEST_ALLOC_SIZE (env[1], 8);
923
893
                        TEST_EQ_STR (env[1], "BAZ=QUX");
 
894
                        removed = env[1];
 
895
                        TEST_FREE_TAG (removed);
924
896
 
925
897
                        TEST_EQ_P (env[2], NULL);
926
898
                }
930
902
 
931
903
                if (test_alloc_failed) {
932
904
                        TEST_EQ_P (ret, NULL);
933
 
 
934
 
                        TEST_EQ (len, 2);
935
 
                        TEST_ALLOC_PARENT (env[0], env);
936
 
                        TEST_ALLOC_SIZE (env[0], 8);
937
 
                        TEST_EQ_STR (env[0], "FOO=BAR");
938
 
 
939
 
                        TEST_ALLOC_PARENT (env[1], env);
940
 
                        TEST_ALLOC_SIZE (env[1], 8);
941
 
                        TEST_EQ_STR (env[1], "BAZ=QUX");
942
 
 
943
 
                        TEST_EQ_P (env[2], NULL);
944
 
 
945
905
                        nih_free (env);
946
906
                        continue;
947
907
                }
954
914
                TEST_EQ_STR (env[0], "FOO=BAR");
955
915
 
956
916
                TEST_EQ_P (env[1], NULL);
 
917
                TEST_FREE (removed);
957
918
 
958
919
                nih_free (env);
959
920
        }
991
952
                        /* Should have been expanded */
992
953
                        TEST_EQ_STR (env[1], "UPSTART_TEST_VARIABLE=foo");
993
954
 
 
955
                        removed = env[1];
 
956
                        TEST_FREE_TAG (removed);
 
957
 
994
958
                        TEST_EQ_P (env[2], NULL);
995
959
                }
996
960
 
999
963
 
1000
964
                if (test_alloc_failed) {
1001
965
                        TEST_EQ_P (ret, NULL);
1002
 
 
1003
 
                        TEST_EQ (len, 2);
1004
 
                        TEST_ALLOC_PARENT (env[0], env);
1005
 
                        TEST_ALLOC_SIZE (env[0], 8);
1006
 
                        TEST_EQ_STR (env[0], "FOO=BAR");
1007
 
 
1008
 
                        TEST_ALLOC_PARENT (env[1], env);
1009
 
                        TEST_ALLOC_SIZE (env[1], 8);
1010
 
                        TEST_EQ_STR (env[1], "UPSTART_TEST_VARIABLE=foo");
1011
 
 
1012
 
                        TEST_EQ_P (env[2], NULL);
1013
 
 
1014
966
                        nih_free (env);
1015
967
                        continue;
1016
968
                }
1023
975
                TEST_EQ_STR (env[0], "FOO=BAR");
1024
976
 
1025
977
                TEST_EQ_P (env[1], NULL);
 
978
                TEST_FREE (removed);
1026
979
 
1027
980
                nih_free (env);
1028
981
        }