rbgccxml 0.8 → 0.9

data/lib/rbgccxml.rb

@@ -1,5 +1,3 @@
-require 'hpricot'
-gem 'gccxml_gem'
 require 'gccxml'
 
 require 'rbgccxml/rbgccxml'
@@ -7,29 +5,35 @@ require 'rbgccxml/rbgccxml'
 module RbGCCXML
 
   # Core classes
-  autoload :Parser, "rbgccxml/parser"
-  autoload :Node, "rbgccxml/node"
-  autoload :QueryResult, "rbgccxml/query_result"
-  autoload :XMLParsing, "rbgccxml/xml_parsing"
+  autoload :Node,             "rbgccxml/node"
+  autoload :Parser,           "rbgccxml/parser"
+  autoload :XMLParsing,       "rbgccxml/xml_parsing"
+  autoload :QueryResult,      "rbgccxml/query_result"
 
   # Nodes
-  autoload :Argument, "rbgccxml/nodes/argument" 
-  autoload :Class, "rbgccxml/nodes/class" 
-  autoload :Constructor, "rbgccxml/nodes/constructor" 
-  autoload :File, "rbgccxml/nodes/file" 
-  autoload :Function, "rbgccxml/nodes/function" 
-  autoload :Method, "rbgccxml/nodes/method" 
-  autoload :Namespace, "rbgccxml/nodes/namespace" 
-  autoload :Struct, "rbgccxml/nodes/struct" 
-  autoload :Enumeration, "rbgccxml/nodes/enumeration"  
-  autoload :EnumValue, "rbgccxml/nodes/enum_value"  
+  autoload :Argument,         "rbgccxml/nodes/argument" 
+  autoload :Base,             "rbgccxml/nodes/base"
+  autoload :Class,            "rbgccxml/nodes/class" 
+  autoload :Constructor,      "rbgccxml/nodes/constructor" 
+  autoload :Destructor,       "rbgccxml/nodes/destructor"
+  autoload :Enumeration,      "rbgccxml/nodes/enumeration"  
+  autoload :EnumValue,        "rbgccxml/nodes/enum_value"  
+  autoload :Field,            "rbgccxml/nodes/field" 
+  autoload :File,             "rbgccxml/nodes/file" 
+  autoload :FunctionType,     "rbgccxml/nodes/function_type"
+  autoload :Function,         "rbgccxml/nodes/function" 
+  autoload :Method,           "rbgccxml/nodes/method" 
+  autoload :Namespace,        "rbgccxml/nodes/namespace" 
+  autoload :Struct,           "rbgccxml/nodes/struct" 
+  autoload :Variable,         "rbgccxml/nodes/variable" 
 
   # Type Management
-  autoload :Type, "rbgccxml/nodes/type"
-  autoload :FundamentalType, "rbgccxml/nodes/types/fundamental_type" 
-  autoload :PointerType, "rbgccxml/nodes/types/pointer_type" 
-  autoload :Typedef, "rbgccxml/nodes/types/typedef" 
-  autoload :ReferenceType, "rbgccxml/nodes/types/reference_type"
-  autoload :CvQualifiedType, "rbgccxml/nodes/types/cv_qualified_type"  
+  autoload :Type,             "rbgccxml/nodes/type"
+  autoload :Typedef,          "rbgccxml/nodes/types/typedef" 
+  autoload :ArrayType,        "rbgccxml/nodes/types/array_type"
+  autoload :PointerType,      "rbgccxml/nodes/types/pointer_type" 
+  autoload :ReferenceType,    "rbgccxml/nodes/types/reference_type"
+  autoload :CvQualifiedType,  "rbgccxml/nodes/types/cv_qualified_type"  
+  autoload :FundamentalType,  "rbgccxml/nodes/types/fundamental_type" 
 
 end

data/test/arguments_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+context "Function and Method Arguments" do
+
+  setup do
+    @@arguments_source ||= RbGCCXML.parse(full_dir("headers/functions.h")).namespaces("functions")
+  end
+
+  specify "have type and to_cpp" do
+    test1 = @@arguments_source.functions("test1")
+    test1.arguments.length.should.equal 2
+
+    test1.arguments[0].to_cpp.should.equal "int x"
+    test1.arguments[0].cpp_type.to_cpp.should.equal "int"
+
+    test1.arguments[1].to_cpp.should.equal "double y"
+    test1.arguments[1].cpp_type.to_cpp.should.equal "double"
+  end
+
+  specify "can have a default value" do
+    test1 = @@arguments_source.functions("test1")
+    test1.arguments[0].value.should.be nil
+    test1.arguments[1].value.should.equal "3.0e+0"
+
+    rockin = @@arguments_source.functions("rockin")
+    rockin.arguments[1].value.should.equal "functions::test()"
+  end
+end
+

data/test/classes_test.rb

@@ -1,60 +1,198 @@
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Querying for classes" do
   setup do
-    @@source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+    @source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
   end
 
   specify "can find all classes in a given namespace" do
-    classes = @@source.classes
-    classes.size.should == 4
+    classes = @source.classes
+    classes.size.should.equal 4
 
-    %w(Test1 Test2 Test3).each do |t|
-      assert classes.detect {|c| c.node == @@source.classes(t).node }, 
-        "unable to find node for #{t}"
-    end
+    classes.find(:name => "Test1").should.not.be.nil
+    classes.find(:name => "Test2").should.not.be.nil
+    classes.find(:name => "Test3").should.not.be.nil
   end
 
   specify "can find classes within classes" do
-    test1 = @@source.classes.find(:name => "Test1")
+    test1 = @source.classes.find(:name => "Test1")
     test1.should.not.be.nil
-    
+    test1.should.be.kind_of RbGCCXML::Class
+    test1.name.should.equal "Test1"
+
     inner1 = test1.classes("Inner1")
     inner1.should.not.be.nil
-    
+    inner1.should.be.kind_of RbGCCXML::Class
+    inner1.name.should.equal "Inner1"
+
     inner2 = inner1.classes("Inner1")
     inner2.should.not.be.nil
+    inner2.should.be.kind_of Array
+    inner2.should.be.empty
+
+    inner2 = inner1.classes("Inner2")
+    inner2.should.not.be.nil
+    inner2.should.be.kind_of RbGCCXML::Class
+    inner2.name.should.equal "Inner2"
+  end
+
+  specify "can find classes within classes by regex" do
+    test1 = @source.classes(/t1/)
+    test1.should.not.be.nil
+    test1.should.be.kind_of RbGCCXML::Class
+    test1.name.should.equal "Test1"
+
+    inner1 = test1.classes(/In.*1/)
+    inner1.should.not.be.nil
+    inner1.should.be.kind_of RbGCCXML::Class
+    inner1.name.should.equal "Inner1"
+
+    inner2 = inner1.classes(/1/)
+    inner2.should.not.be.nil
+    inner2.should.be.kind_of Array
+    inner2.should.be.empty
+
+    inner2 = inner1.classes(/2/)
+    inner2.should.not.be.nil
+    inner2.should.be.kind_of RbGCCXML::Class
+    inner2.name.should.equal "Inner2"
   end
 
-  specify "can find out which file said class is in" do
-    test1 = @@source.classes.find(:name => "Test1")
-    test1.file_name.should == "classes.h"
+  specify "can find classes within classes by block" do
+    # We're looking for any class that has virtual methods.
+    test4 = @source.classes { |c| c.methods.any? { |m| m.virtual? } }
+    test4.should.not.be.nil
+    test4.should.be.kind_of RbGCCXML::Class
+    test4.name.should.equal "Test4"
+
+    # Fail case -- there's no methods that return double.
+    test0 = @source.classes { |c| c.methods.any? { |m| m.return_type == "double" }}
+    test0.should.not.be.nil
+    test0.should.be.kind_of Array
+    test0.should.be.empty
+  end
+
+  specify "can tell if a class is pure virtual" do
+    test1 = @source.classes("Test1")
+    test4 = @source.classes("Test4")
+
+    test1.pure_virtual?.should.be false
+    test4.pure_virtual?.should.be true
   end
 end
 
 context "Querying for class constructors" do
   setup do
-    @@source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+    @source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
   end
 
   specify "should have a list of constructors" do
-    test1 = @@source.classes.find(:name => "Test1")
-    test1.constructors.size.should == 2
+    test1 = @source.classes.find(:name => "Test1")
+    test1.constructors.size.should.equal 2
 
-    test2 = @@source.classes.find(:name => "Test2")
-    test2.constructors.size.should == 2
+    test2 = @source.classes.find(:name => "Test2")
+    test2.constructors.size.should.equal 3
   end
 
   specify "constructors should have arguments" do
-    test2 = @@source.classes.find(:name => "Test2")
-    test2.constructors.size.should == 2
+    test2 = @source.classes.find(:name => "Test2")
+    test2.constructors.size.should.equal 3
+
+    # GCC generated copy constructors
+    copy = test2.constructors[0]
+    copy.attributes[:artificial].should.equal "1"
 
-    default = test2.constructors[0]
-    default.arguments.size.should == 0
+    default = test2.constructors[1]
+    default.arguments.size.should.equal 0
 
-    specific = test2.constructors[1]
-    specific.arguments.size.should == 1
-    assert(specific.arguments[0].cpp_type == "int")
+    specific = test2.constructors[2]
+    specific.arguments.size.should.equal 1
+    specific.arguments[0].cpp_type.name.should.equal "int"
   end
 end
 
+context "Querying for the class's deconstructor" do
+  setup do
+    @source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+  end
+
+  specify "can tell if a class has an explicit destructor" do
+    test1 = @source.classes("Test1")
+    test1.destructor.should.not.be.nil
+    test1.destructor.attributes[:artificial].should.be.nil
+
+    test2 = @source.classes("Test2")
+    test2.destructor.should.not.be.nil
+    test2.destructor.attributes[:artificial].should.not.be.nil
+  end
+
+end
+
+context "Query for class variables" do
+  setup do
+    @source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+  end
+
+  specify "find all i-vars" do
+    test1 = @source.classes("Test1")
+    test1.variables.length.should.equal 4
+  end
+
+  specify "can find by access level" do
+    test1 = @source.classes("Test1")
+    test1.variables.find(:access => "public").length.should.equal 2
+    test1.variables.find(:access => "protected").name.should.equal "protVariable"
+    test1.variables.find(:access => "private").name.should.equal "privateVariable"
+  end
+end
+
+context "Query inheritance heirarchy" do
+  setup do
+    @source ||= RbGCCXML.parse(full_dir("headers/inheritance.h")).namespaces("inheritance")
+  end
+
+  specify "can find a class's superclass" do
+    pc = @source.classes("ParentClass")
+    pc.superclass.should.be.nil
+
+    base1 = @source.classes("Base1")
+    base1.superclass.should.not.be.nil
+    base1.superclass.name.should.equal "ParentClass"
+  end
+
+  specify "can query for multiple inheritance" do
+    multi = @source.classes("MultiBase")
+    multi.superclasses.length.should.equal 2
+    assert multi.superclasses.select {|sp| sp.name == "ParentClass"}
+    assert multi.superclasses.select {|sp| sp.name == "Parent2"}
+  end
+
+  specify "calling #superclasses always returns an array" do
+    pc = @source.classes("ParentClass")
+    pc.superclasses.should.be.empty
+
+    base1 = @source.classes("Base1")
+    base1.superclasses.length.should.equal 1
+    base1.superclasses[0].name.should.equal "ParentClass"
+  end
+
+  specify "can infinitely climb the inheritance heirarchy" do
+    low = @source.classes("VeryLow")
+    low.superclass.superclass.superclass.name.should.equal "ParentClass"
+  end
+
+  specify "can query for types of inheritance" do
+    pvb1 = @source.classes("PrivateBase1")
+    pvb1.superclass(:public).should.be.nil
+    pvb1.superclass(:protected).should.be.nil
+    pvb1.superclass(:private).should.not.be.nil
+
+    pvb1.superclass(:private).name.should.equal "ParentClass"
+
+    pvb1.superclasses(:public).length.should.equal 0
+    pvb1.superclasses(:protected).length.should.equal 0
+    pvb1.superclasses(:private).length.should.equal 1
+  end
+
+end
+

data/test/enumerations_test.rb

@@ -1,5 +1,4 @@
-
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Querying for enumerations" do
   setup do
@@ -8,37 +7,46 @@ context "Querying for enumerations" do
 
   specify "can query for enumerations" do
     enums = @@enum_source.enumerations
-    enums.length.should == 2
-
-    assert @@enum_source.enumerations("TestEnum") == "TestEnum"
-    assert @@enum_source.enumerations.find(:name => "MyEnum") == "MyEnum"
+    enums.length.should.equal 3
   end
 
   specify "can find specific enum values" do
     enum = @@enum_source.enumerations("TestEnum")
-    enum.values.length.should == 3
-    assert enum.values[0] == "VALUE1"
-    assert enum.values[1] == "VALUE2"
-    assert enum.values[2] == "VALUE3"
+    enum.values.length.should.equal 3
+    enum.values[0].name.should.equal "VALUE1"
+    enum.values[1].name.should.equal "VALUE2"
+    enum.values[2].name.should.equal "VALUE3"
   end
 
   specify "can find the given value of enum entries" do
     enum = @@enum_source.enumerations.find(:name => "MyEnum")
-    enum.values[0].value.should == 3
-    enum.values[1].value.should == 4
-    enum.values[2].value.should == 7
+    enum.values[0].value.should.equal 3
+    enum.values[1].value.should.equal 4
+    enum.values[2].value.should.equal 7
   end
 
   specify "properly prints out fully qualified C++ identifier for enum values" do
     enum = @@enum_source.enumerations("TestEnum")
-    enum.values.length.should == 3
-    assert enum.values[0].qualified_name == "enums::VALUE1"
-    assert enum.values[1].qualified_name == "enums::VALUE2"
-    assert enum.values[2].qualified_name == "enums::VALUE3"
+    enum.values.length.should.equal 3
+    enum.values[0].qualified_name.should.equal "enums::VALUE1"
+    enum.values[1].qualified_name.should.equal "enums::VALUE2"
+    enum.values[2].qualified_name.should.equal "enums::VALUE3"
 
     enum = @@enum_source.classes("Inner").enumerations("InnerEnum")
-    assert enum.values[0].qualified_name == "enums::Inner::INNER_1"
-    assert enum.values[1].qualified_name == "enums::Inner::INNER_2"
+    enum.values[0].qualified_name.should.equal "enums::Inner::INNER_1"
+    enum.values[1].qualified_name.should.equal "enums::Inner::INNER_2"
+  end
+
+  specify "knows if an enumeration is anonymous" do
+    found = @@enum_source.enumerations.select {|e| e.anonymous? }
+    found.length.should.equal 1
+    found = found[0]
+
+    assert found.is_a?(RbGCCXML::Enumeration)
+    found.values[0].value.should.equal 0
+    found.values[1].value.should.equal 1
+    found.values[2].value.should.equal 2
   end
+
 end
 

data/test/function_pointers_test.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+
+context "Function pointers" do
+  setup do
+    @@fp_source ||= RbGCCXML.parse(full_dir("headers/types.h")).namespaces("types")
+  end
+
+  specify "have arguments" do
+    fp = @@fp_source.functions("takesCallback").arguments[0].cpp_type.base_type
+    fp.arguments.length.should == 1
+    fp.arguments[0].cpp_type.name.should.equal "int"
+  end
+
+  specify "have return value" do
+    fp = @@fp_source.functions("takesCallbackWithReturn").arguments[0].cpp_type.base_type
+    fp.return_type.name.should.equal "int"
+  end
+end

data/test/functions_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Querying for functions" do
 
@@ -7,7 +7,7 @@ context "Querying for functions" do
   end
 
   specify "should be able to find all functions" do
-    @@functions_source.functions.length.should == 2
+    @@functions_source.functions.length.should == 4
   end
 
   specify "can find functions by name" do
@@ -41,4 +41,9 @@ context "Querying for functions" do
       test1.functions  
     end
   end
+
+  specify "can get list of arguments" do
+    test1 = @@functions_source.functions("test1")
+    test1.arguments.length.should.equal 2
+  end
 end

data/test/methods_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Querying for class methods" do
   setup do
@@ -32,12 +32,12 @@ context "Querying for class methods" do
 
   specify "can search methods via return type" do
     adder = @@adder_source.classes("Adder")
-    adder.methods.find(:returns => [:float]).name.should == "addFloats"
+    adder.methods.find(:returns => :float).name.should == "addFloats"
   end
 
   specify "can search via all options (AND)" do
     adder = @@adder_source.classes("Adder")
-    got = adder.methods.find(:returns => [:int], :arguments => [nil, nil])
+    got = adder.methods.find(:returns => :int, :arguments => [nil, nil])
     got.name.should == "addIntegers"
   end
 

data/test/namespaces_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Querying for namespaces" do
 

data/test/node_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Qualified name generation" do
 
@@ -41,36 +41,6 @@ context "Qualified name generation" do
 
 end
 
-context "Equality testing" do
-
-  specify "testing against a string will test against the name" do
-    source = RbGCCXML.parse(full_dir("headers/namespaces.h"))
-    assert(source.namespaces("upper") == "upper")
-  end
-
-  specify "c++ nesting should be usable as well" do
-    source = RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
-    klass = source.classes("Test1").classes("Inner1")
-    assert !(klass == "Inner2")
-    assert(klass == "Inner1")
-    assert(klass == "Test1::Inner1")
-    assert(klass == "classes::Test1::Inner1")
-  end
-
-  specify "but should be able to test against nodes as well" do
-    source = RbGCCXML.parse(full_dir("headers/namespaces.h"))
-    upper = source.namespaces("upper")
-    inner = upper.namespaces("inner1")
-    assert !(upper == inner)
-  end
-
-  specify "should find explicit over matches" do
-    source = RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
-    f = source.classes("Test2").methods("func")
-    f.name.should == "func"
-  end
-end
-
 context "Misc access methods" do
 
   specify "can tell if something is public, protected, and private" do
@@ -82,4 +52,14 @@ context "Misc access methods" do
     assert access.methods("publicMethod").public?
   end
 
+  specify "can get the full file path of a node" do
+    source = RbGCCXML.parse(full_dir("headers/enums.h")).namespaces("enums")
+    source.enumerations("TestEnum").file.should =~ "enums.h"
+  end
+
+  specify "returns nil if no file node is found" do
+    source = RbGCCXML.parse(full_dir("headers/enums.h")).namespaces("enums")
+    source.file.should.be nil
+  end
+
 end

data/test/parser_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Default parsing configuration" do
 

data/test/query_results_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Managing Query results" do
 
@@ -94,7 +94,7 @@ context "QueryResult#find :arguments" do
     func.name.should == "test3"
   end
 
-  specify "when searching arguments, can specify catch-all" do
+  specify "when searching arguments, can xspecify catch-all" do
     funcs = @@query_source.functions.find(:arguments => [:int, nil])
     funcs.size.should == 2
     assert funcs.detect {|f| f.name == "test3" }
@@ -103,23 +103,23 @@ context "QueryResult#find :arguments" do
 
   specify "works when using custom defined types" do
     func = @@query_source.functions.find(:arguments => ["MyType"])
-    func.name.should == "testMyTypeArgs"
+    func.name.should.equal "testMyTypeArgs"
   end
 
   specify "works with pointers and references" do
-    func = @@query_source.functions.find(:arguments => ["MyType *"])
-    func.name.should == "testMyTypeArgsPtr"
+    func = @@query_source.functions.find(:arguments => ["MyType*"])
+    func.length.should.equal 2
 
-    func = @@query_source.functions.find(:arguments => ["MyType &"])
+    func = @@query_source.functions.find(:arguments => ["MyType&"])
     func.name.should == "testMyTypeArgsRef"
   end
 
   specify "works with qualified names" do
     func = @@query_source.functions.find(:arguments => ["query::MyType"])
-    func.name.should == "testMyTypeArgs"
+    func.name.should.equal "testMyTypeArgs"
 
     func = @@query_source.functions.find(:arguments => ["::query::MyType"])
-    func.name.should == "testMyTypeArgs"
+    func.name.should.equal "testMyTypeArgs"
   end
 
   specify "works with qualifiers like const" do
@@ -143,19 +143,19 @@ context "QueryResult#find :returns" do
 
   specify "works with custom defined types" do
     func = @@query_source.functions.find(:returns => "MyType")
-    func.name.should == "testMyType"
+    func.length.should.equal 2
   end
 
   specify "work with qualified names" do
     func = @@query_source.functions.find(:returns => "query::MyType")
-    func.name.should == "testMyType"
+    func.length.should.equal 2
 
     func = @@query_source.functions.find(:returns => "::query::MyType")
-    func.name.should == "testMyType"
+    func.length.should.equal 2
   end
 
   specify "works with pointers and references" do
-    func = @@query_source.functions.find(:returns => "MyType *")
+    func = @@query_source.functions.find(:returns => "MyType*")
     func.name.should == "testMyTypePtr"
 
     func = @@query_source.functions.find(:returns => "MyType&")
@@ -219,10 +219,11 @@ context "QueryResult#find :all - Flag full source search" do
   end
   
   specify "can find according to :returns " do
-    funcs = @@query_source.functions.find(:all, :returns => ["MyType"])
-    funcs.size.should == 2
+    funcs = @@query_source.functions.find(:all, :returns => "MyType")
+    funcs.size.should == 3
     assert funcs.detect {|f| f.name == "nestedMyTypeReturns"}
     assert funcs.detect {|f| f.name == "testMyType"}
+    assert funcs.detect {|f| f.name == "testMyTypeConst"}
   end
 
 end

data/test/structs_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require "test_helper"
 
 context "Querying for structs" do
   setup do
@@ -25,11 +25,6 @@ context "Querying for structs" do
     inner2 = inner1.structs("Inner1")
     inner2.should.not.be.nil
   end
-
-  specify "can find out which file said class is in" do
-    test1 = @@structs_source.structs.find(:name => "Test1")
-    test1.file_name.should == "structs.h"
-  end
 end
 
 context "Querying for struct constructors" do
@@ -39,22 +34,25 @@ context "Querying for struct constructors" do
 
   specify "should have a list of constructors" do
     test1 = @@structs_source.structs.find(:name => "Test1")
-    test1.constructors.size.should == 1
+    test1.constructors.size.should == 2
 
     test2 = @@structs_source.structs.find(:name => "Test2")
-    test2.constructors.size.should == 2
+    test2.constructors.size.should == 3
   end
 
   specify "constructors should have arguments" do
     test2 = @@structs_source.structs.find(:name => "Test2")
-    test2.constructors.size.should == 2
 
-    default = test2.constructors[0]
+    # GCC generated copy constructors
+    copy = test2.constructors[0]
+    copy.attributes[:artificial].should == "1"
+
+    default = test2.constructors[1]
     default.arguments.size.should == 0
 
-    specific = test2.constructors[1]
+    specific = test2.constructors[2]
     specific.arguments.size.should == 1
-    assert(specific.arguments[0].cpp_type == "int")
+    specific.arguments[0].cpp_type.name.should.equal "int"
   end
 end